Changes in src/InitTweak/FixInit.cc [f9feab8:1be845b]

File:

• src/InitTweak/FixInit.cc (modified) (34 diffs)

src/InitTweak/FixInit.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// FixInit.h --
+// FixInit.cc --
 //
 // Author           : Rob Schluntz
@@ -54 +54 @@
 #include "SynTree/Type.h"              // for Type, Type::StorageClasses
 #include "SynTree/TypeSubstitution.h"  // for TypeSubstitution, operator<<
-#include "SynTree/VarExprReplacer.h"   // for VarExprReplacer
 #include "SynTree/Visitor.h"           // for acceptAll, maybeAccept
 
@@ -68 +67 @@
         namespace {
                 typedef std::unordered_map< int, int > UnqCount;
+
+                struct SelfAssignChecker {
+                        void previsit( ApplicationExpr * appExpr );
+                };
 
                 struct InsertImplicitCalls : public WithTypeSubstitution {
@@ -159 +162 @@
                         using Parent::previsit;
 
+                        void previsit( ObjectDecl * objDecl );
                         void previsit( FunctionDecl * funcDecl );
 
+                        void previsit( CompoundStmt * compoundStmt );
+                        void postvisit( CompoundStmt * compoundStmt );
+                        void previsit( ReturnStmt * returnStmt );
                         void previsit( BranchStmt * stmt );
                 private:
@@ -180 +187 @@
                 };
 
-                class FixCopyCtors final : public WithStmtsToAdd, public WithShortCircuiting, public WithVisitorRef<FixCopyCtors> {
+                class FixCopyCtors final : public WithStmtsToAdd, public WithShortCircuiting, public WithVisitorRef<FixCopyCtors>, public WithTypeSubstitution {
                   public:
                         FixCopyCtors( UnqCount & unqCount ) : unqCount( unqCount ){}
@@ -194 +201 @@
                 };
 
-                struct GenStructMemberCalls final : public WithGuards, public WithShortCircuiting, public WithIndexer {
+                struct GenStructMemberCalls final : public WithGuards, public WithShortCircuiting, public WithIndexer, public WithVisitorRef<GenStructMemberCalls> {
                         /// generate default/copy ctor and dtor calls for user-defined struct ctor/dtors
                         /// for any member that is missing a corresponding ctor/dtor call.
@@ -200 +207 @@
                         static void generate( std::list< Declaration * > & translationUnit );
 
-                        void previsit( StructDecl * structDecl );
-
-                        void previsit( FunctionDecl * funcDecl );
-                        void postvisit( FunctionDecl * funcDecl );
-
-                        void previsit( MemberExpr * memberExpr );
-                        void previsit( ApplicationExpr * appExpr );
-
-                        SemanticError errors;
+                        void premutate( FunctionDecl * funcDecl );
+                        DeclarationWithType * postmutate( FunctionDecl * funcDecl );
+
+                        void premutate( MemberExpr * memberExpr );
+                        void premutate( ApplicationExpr * appExpr );
+
+                        /// Note: this post mutate used to be in a separate visitor. If this pass breaks, one place to examine is whether it is
+                        /// okay for this part of the recursion to occur alongside the rest.
+                        Expression * postmutate( UntypedExpr * expr );
+
+                        SemanticErrorException errors;
                   private:
                         template< typename... Params >
@@ -219 +228 @@
                         bool isCtor = false; // true if current function is a constructor
                         StructDecl * structDecl = nullptr;
-
-                        // special built-in functions necessary for this to work
-                        StructDecl * dtorStruct = nullptr;
-                        FunctionDecl * dtorStructDestroy = nullptr;
-                };
-
-                // very simple resolver-like mutator class - used to
-                // resolve UntypedExprs that are found within newly
-                // generated constructor/destructor calls
-                class MutatingResolver final : public Mutator {
-                  public:
-                        MutatingResolver( SymTab::Indexer & indexer ) : indexer( indexer ) {}
-
-                        using Mutator::mutate;
-                        virtual DeclarationWithType* mutate( ObjectDecl *objectDecl ) override;
-                        virtual Expression* mutate( UntypedExpr *untypedExpr ) override;
-
-                  private:
-                        SymTab::Indexer & indexer;
                 };
 
@@ -248 +238 @@
         } // namespace
 
-        void fix( std::list< Declaration * > & translationUnit, const std::string & filename, bool inLibrary ) {
+        void fix( std::list< Declaration * > & translationUnit, bool inLibrary ) {
+                PassVisitor<SelfAssignChecker> checker;
+                acceptAll( translationUnit, checker );
+
                 // fixes ConstructorInit for global variables. should happen before fixInitializers.
-                InitTweak::fixGlobalInit( translationUnit, filename, inLibrary );
+                InitTweak::fixGlobalInit( translationUnit, inLibrary );
 
                 UnqCount unqCount;
@@ -290 +283 @@
                         // can't use mutateAll, because need to insert declarations at top-level
                         // can't use DeclMutator, because sometimes need to insert IfStmt, etc.
-                        SemanticError errors;
+                        SemanticErrorException errors;
                         for ( std::list< Declaration * >::iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
                                 try {
                                         maybeMutate( *i, fixer );
                                         translationUnit.splice( i, fixer.pass.staticDtorDecls );
-                                } catch( SemanticError &e ) {
-                                        e.set_location( (*i)->location );
+                                } catch( SemanticErrorException &e ) {
                                         errors.append( e );
                                 } // try
@@ -318 +310 @@
                 void GenStructMemberCalls::generate( std::list< Declaration * > & translationUnit ) {
                         PassVisitor<GenStructMemberCalls> warner;
-                        acceptAll( translationUnit, warner );
+                        mutateAll( translationUnit, warner );
                 }
 
@@ -324 +316 @@
                         PassVisitor<FixCtorExprs> fixer;
                         mutateAll( translationUnit, fixer );
+                }
+
+                namespace {
+                        // Relatively simple structural comparison for expressions, needed to determine
+                        // if two expressions are "the same" (used to determine if self assignment occurs)
+                        struct StructuralChecker {
+                                Expression * stripCasts( Expression * expr ) {
+                                        // this might be too permissive. It's possible that only particular casts are relevant.
+                                        while ( CastExpr * cast = dynamic_cast< CastExpr * >( expr ) ) {
+                                                expr = cast->arg;
+                                        }
+                                        return expr;
+                                }
+
+                                void previsit( Expression * ) {
+                                        // anything else does not qualify
+                                        isSimilar = false;
+                                }
+
+                                template<typename T>
+                                T * cast( Expression * node ) {
+                                        // all expressions need to ignore casts, so this bit has been factored out
+                                        return dynamic_cast< T * >( stripCasts( node ) );
+                                }
+
+                                // ignore casts
+                                void previsit( CastExpr * ) {}
+
+                                void previsit( MemberExpr * memExpr ) {
+                                        if ( MemberExpr * otherMember = cast< MemberExpr >( other ) ) {
+                                                if ( otherMember->member == memExpr->member ) {
+                                                        other = otherMember->aggregate;
+                                                        return;
+                                                }
+                                        }
+                                        isSimilar = false;
+                                }
+
+                                void previsit( VariableExpr * varExpr ) {
+                                        if ( VariableExpr * otherVar = cast< VariableExpr >( other ) ) {
+                                                if ( otherVar->var == varExpr->var ) {
+                                                        return;
+                                                }
+                                        }
+                                        isSimilar = false;
+                                }
+
+                                void previsit( AddressExpr * ) {
+                                        if ( AddressExpr * addrExpr = cast< AddressExpr >( other ) ) {
+                                                other = addrExpr->arg;
+                                                return;
+                                        }
+                                        isSimilar = false;
+                                }
+
+                                Expression * other = nullptr;
+                                bool isSimilar = true;
+                        };
+
+                        bool structurallySimilar( Expression * e1, Expression * e2 ) {
+                                PassVisitor<StructuralChecker> checker;
+                                checker.pass.other = e2;
+                                e1->accept( checker );
+                                return checker.pass.isSimilar;
+                        }
+                }
+
+                void SelfAssignChecker::previsit( ApplicationExpr * appExpr ) {
+                        DeclarationWithType * function = getFunction( appExpr );
+                        if ( function->name == "?=?" ) { // doesn't use isAssignment, because ?+=?, etc. should not count as self-assignment
+                                if ( appExpr->args.size() == 2 ) {
+                                        // check for structural similarity (same variable use, ignore casts, etc. - but does not look too deeply, anything looking like a function is off limits)
+                                        if ( structurallySimilar( appExpr->args.front(), appExpr->args.back() ) ) {
+                                                SemanticWarning( appExpr->location, Warning::SelfAssignment, toCString( appExpr->args.front() ) );
+                                        }
+                                }
+                        }
                 }
 
@@ -368 +437 @@
                         // arrays are not copy constructed, so this should always be an ExprStmt
                         ImplicitCtorDtorStmt * stmt = genCtorDtor( fname, var, cpArg );
-                        ExprStmt * exprStmt = strict_dynamic_cast< ExprStmt * >( stmt->get_callStmt() );
+                        assertf( stmt, "ResolveCopyCtors: genCtorDtor returned nullptr: %s / %s / %s", fname.c_str(), toString( var ).c_str(), toString( cpArg ).c_str() );
+                        ExprStmt * exprStmt = strict_dynamic_cast< ExprStmt * >( stmt->callStmt );
                         Expression * resolved = exprStmt->expr;
                         exprStmt->expr = nullptr; // take ownership of expr
@@ -378 +448 @@
                         ResolvExpr::findVoidExpression( resolved, indexer );
                         assert( resolved );
-                        if ( resolved->get_env() ) {
+                        if ( resolved->env ) {
                                 // Extract useful information and discard new environments. Keeping them causes problems in PolyMutator passes.
-                                env->add( *resolved->get_env() );
-                                delete resolved->get_env();
-                                resolved->set_env( nullptr );
+                                env->add( *resolved->env );
+                                delete resolved->env;
+                                resolved->env = nullptr;
                         } // if
                         delete stmt;
+                        if ( TupleAssignExpr * assign = dynamic_cast< TupleAssignExpr * >( resolved ) ) {
+                                // fix newly generated StmtExpr
+                                postvisit( assign->stmtExpr );
+                        }
                         return resolved;
                 }
@@ -478 +552 @@
                                 static UniqueName retNamer("_tmp_stmtexpr_ret");
 
-                                // create variable that will hold the result of the stmt expr
                                 result = result->clone();
                                 env->apply( result );
+                                if ( ! InitTweak::isConstructable( result ) ) {
+                                        delete result;
+                                        return;
+                                }
+
+                                // create variable that will hold the result of the stmt expr
                                 ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
-                                ret->get_type()->set_const( false );
-                                stmtExpr->get_returnDecls().push_front( ret );
+                                ret->type->set_const( false );
+                                stmtExpr->returnDecls.push_front( ret );
 
                                 // must have a non-empty body, otherwise it wouldn't have a result
-                                CompoundStmt * body = stmtExpr->get_statements();
+                                CompoundStmt * body = stmtExpr->statements;
                                 assert( ! body->get_kids().empty() );
                                 // must be an ExprStmt, otherwise it wouldn't have a result
                                 ExprStmt * last = strict_dynamic_cast< ExprStmt * >( body->get_kids().back() );
-                                last->set_expr( makeCtorDtor( "?{}", ret, last->get_expr() ) );
-
-                                stmtExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
+                                last->expr = makeCtorDtor( "?{}", ret, last->get_expr() );
+
+                                stmtExpr->dtors.push_front( makeCtorDtor( "^?{}", ret ) );
                         } // if
                 }
@@ -555 +634 @@
                         // add destructors after current statement
                         for ( Expression * dtor : dtors ) {
+                                // take relevant bindings from environment
+                                assert( ! dtor->env );
+                                dtor->env =  maybeClone( env );
                                 stmtsToAddAfter.push_back( new ExprStmt( dtor ) );
                         } // for
@@ -593 +675 @@
                         // to the outer context, rather than inside of the statement expression.
                         visit_children = false;
-                        std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
+                        std::list< Statement * > & stmts = stmtExpr->statements->get_kids();
                         for ( Statement *& stmt : stmts ) {
                                 stmt = stmt->acceptMutator( *visitor );
                         } // for
-                        assert( stmtExpr->get_result() );
-                        Type * result = stmtExpr->get_result();
+                        assert( stmtExpr->result );
+                        Type * result = stmtExpr->result;
                         if ( ! result->isVoid() ) {
-                                for ( ObjectDecl * obj : stmtExpr->get_returnDecls() ) {
+                                for ( ObjectDecl * obj : stmtExpr->returnDecls ) {
                                         stmtsToAddBefore.push_back( new DeclStmt( obj ) );
                                 } // for
                                 // add destructors after current statement
-                                for ( Expression * dtor : stmtExpr->get_dtors() ) {
+                                for ( Expression * dtor : stmtExpr->dtors ) {
                                         stmtsToAddAfter.push_back( new ExprStmt( dtor ) );
                                 } // for
                                 // must have a non-empty body, otherwise it wouldn't have a result
                                 assert( ! stmts.empty() );
-                                assert( ! stmtExpr->get_returnDecls().empty() );
-                                stmts.push_back( new ExprStmt( new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
-                                stmtExpr->get_returnDecls().clear();
-                                stmtExpr->get_dtors().clear();
-                        }
-                        assert( stmtExpr->get_returnDecls().empty() );
-                        assert( stmtExpr->get_dtors().empty() );
+                                assertf( ! stmtExpr->returnDecls.empty() || stmtExpr->dtors.empty(), "StmtExpr returns non-void, but no return decls: %s", toString( stmtExpr ).c_str() );
+                                // if there is a return decl, add a use as the last statement; will not have return decl on non-constructable returns
+                                if ( ! stmtExpr->returnDecls.empty() ) {
+                                        stmts.push_back( new ExprStmt( new VariableExpr( stmtExpr->returnDecls.front() ) ) );
+                                }
+                                stmtExpr->returnDecls.clear();
+                                stmtExpr->dtors.clear();
+                        }
+                        assert( stmtExpr->returnDecls.empty() );
+                        assert( stmtExpr->dtors.empty() );
                 }
 
@@ -645 +730 @@
                         }
                         return;
-                }
-
-                DeclarationWithType * getDtorFunc( ObjectDecl * objDecl, Statement * input, std::list< Statement * > & stmtsToAdd ) {
-                        // unwrap implicit statement wrapper
-                        Statement * dtor = input;
-                        if ( ImplicitCtorDtorStmt * implicit = dynamic_cast< ImplicitCtorDtorStmt * >( input ) ) {
-                                // dtor = implicit->callStmt;
-                                // implicit->callStmt = nullptr;
-                        }
-                        assert( dtor );
-                        std::list< Expression * > matches;
-                        collectCtorDtorCalls( dtor, matches );
-
-                        if ( dynamic_cast< ExprStmt * >( dtor ) ) {
-                                // only one destructor call in the expression
-                                if ( matches.size() == 1 ) {
-                                        DeclarationWithType * 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 ( FunctionDecl * dtorFunc = dynamic_cast< 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.
-                                                        delete dtor;
-                                                        return func;
-                                                }
-                                        }
-                                }
-                        }
-
-                        // otherwise the cleanup is more complicated - need to build a single argument cleanup function that
-                        // wraps the more complicated code.
-                        static UniqueName dtorNamer( "__cleanup_dtor" );
-                        FunctionDecl * dtorFunc = FunctionDecl::newFunction( dtorNamer.newName(), SymTab::genDefaultType( objDecl->type->stripReferences(), false ), new CompoundStmt() );
-                        stmtsToAdd.push_back( new DeclStmt( dtorFunc ) );
-
-                        // the original code contains uses of objDecl - replace them with the newly generated 'this' parameter.
-                        ObjectDecl * thisParam = getParamThis( dtorFunc->type );
-                        Expression * replacement = new VariableExpr( thisParam );
-
-                        Type * base = replacement->result->stripReferences();
-                        if ( dynamic_cast< ArrayType * >( base ) || dynamic_cast< TupleType * > ( base ) ) {
-                                // need to cast away reference for array types, since the destructor is generated without the reference type,
-                                // and for tuple types since tuple indexing does not work directly on a reference
-                                replacement = new CastExpr( replacement, base->clone() );
-                        }
-                        VarExprReplacer::replace( dtor, { std::make_pair( objDecl, replacement ) } );
-                        dtorFunc->statements->push_back( dtor );
-
-                        return dtorFunc;
                 }
 
@@ -810 +844 @@
                                                         ctorInit->ctor = nullptr;
                                                 }
-
-                                                Statement * dtor = ctorInit->dtor;
-                                                if ( dtor ) {
-                                                        ImplicitCtorDtorStmt * implicit = strict_dynamic_cast< ImplicitCtorDtorStmt * >( dtor );
-                                                        Statement * 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
-                                                                DeclarationWithType * dtorFunc = getDtorFunc( objDecl, dtorStmt, stmtsToAddBefore );
-                                                                objDecl->attributes.push_back( new Attribute( "cleanup", { new VariableExpr( dtorFunc ) } ) );
-                                                                ctorInit->dtor = nullptr;
-                                                        } // if
-                                                }
                                         } // if
                                 } else if ( Initializer * init = ctorInit->init ) {
@@ -867 +886 @@
 
 
+                template<typename Iterator, typename OutputIterator>
+                void insertDtors( Iterator begin, Iterator end, OutputIterator out ) {
+                        for ( Iterator it = begin ; it != end ; ++it ) {
+                                // extract destructor statement from the object decl and insert it into the output. Note that this is
+                                // only called on lists of non-static objects with implicit non-intrinsic dtors, so if the user manually
+                                // calls an intrinsic dtor then the call must (and will) still be generated since the argument may
+                                // contain side effects.
+                                ObjectDecl * objDecl = *it;
+                                ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() );
+                                assert( ctorInit && ctorInit->get_dtor() );
+                                *out++ = ctorInit->get_dtor()->clone();
+                        } // for
+                }
+
+                void InsertDtors::previsit( ObjectDecl * objDecl ) {
+                        // remember non-static destructed objects so that their destructors can be inserted later
+                        if ( ! objDecl->get_storageClasses().is_static ) {
+                                if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) {
+                                        // a decision should have been made by the resolver, so ctor and init are not both non-NULL
+                                        assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() );
+                                        Statement * dtor = ctorInit->get_dtor();
+                                        // don't need to call intrinsic dtor, because it does nothing, but
+                                        // non-intrinsic dtors must be called
+                                        if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
+                                                // set dtor location to the object's location for error messages
+                                                ctorInit->dtor->location = objDecl->location;
+                                                reverseDeclOrder.front().push_front( objDecl );
+                                        } // if
+                                } // if
+                        } // if
+                }
+
                 void InsertDtors::previsit( FunctionDecl * funcDecl ) {
                         // each function needs to have its own set of labels
@@ -879 +930 @@
                 }
 
+                void InsertDtors::previsit( CompoundStmt * compoundStmt ) {
+                        // visit statements - this will also populate reverseDeclOrder list.  don't want to dump all destructors
+                        // when block is left, just the destructors associated with variables defined in this block, so push a new
+                        // list to the top of the stack so that we can differentiate scopes
+                        reverseDeclOrder.push_front( OrderedDecls() );
+                        Parent::previsit( compoundStmt );
+                }
+
+                void InsertDtors::postvisit( CompoundStmt * compoundStmt ) {
+                        // add destructors for the current scope that we're exiting, unless the last statement is a return, which
+                        // causes unreachable code warnings
+                        std::list< Statement * > & statements = compoundStmt->get_kids();
+                        if ( ! statements.empty() && ! dynamic_cast< ReturnStmt * >( statements.back() ) ) {
+                                insertDtors( reverseDeclOrder.front().begin(), reverseDeclOrder.front().end(), back_inserter( statements ) );
+                        }
+                        reverseDeclOrder.pop_front();
+                }
+
+                void InsertDtors::previsit( ReturnStmt * ) {
+                        // return exits all scopes, so dump destructors for all scopes
+                        for ( OrderedDecls & od : reverseDeclOrder ) {
+                                insertDtors( od.begin(), od.end(), back_inserter( stmtsToAddBefore ) );
+                        } // for
+                }
+
                 // Handle break/continue/goto in the same manner as C++.  Basic idea: any objects that are in scope at the
                 // BranchStmt but not at the labelled (target) statement must be destructed.  If there are any objects in scope
@@ -905 +981 @@
                         )
                         if ( ! diff.empty() ) {
-                                throw SemanticError( std::string("jump to label '") + stmt->get_target().get_name() + "' crosses initialization of " + (*diff.begin())->get_name() + " ", stmt );
+                                SemanticError( stmt, std::string("jump to label '") + stmt->get_target().get_name() + "' crosses initialization of " + (*diff.begin())->get_name() + " " );
+                        } // if
+                        // S_G-S_L results in set of objects that must be destructed
+                        diff.clear();
+                        std::set_difference( curVars.begin(), curVars.end(), lvars.begin(), lvars.end(), std::inserter( diff, diff.end() ) );
+                        DTOR_PRINT(
+                                std::cerr << "S_G-S_L = " << printSet( diff ) << std::endl;
+                        )
+                        if ( ! diff.empty() ) {
+                                // create an auxilliary set for fast lookup -- can't make diff a set, because diff ordering should be consistent for error messages.
+                                std::unordered_set<ObjectDecl *> needsDestructor( diff.begin(), diff.end() );
+
+                                // go through decl ordered list of objectdecl. for each element that occurs in diff, output destructor
+                                OrderedDecls ordered;
+                                for ( OrderedDecls & rdo : reverseDeclOrder ) {
+                                        // add elements from reverseDeclOrder into ordered if they occur in diff - it is key that this happens in reverse declaration order.
+                                        copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return needsDestructor.count( objDecl ); } );
+                                } // for
+                                insertDtors( ordered.begin(), ordered.end(), back_inserter( stmtsToAddBefore ) );
                         } // if
                 }
@@ -931 +1025 @@
                 }
 
-                void GenStructMemberCalls::previsit( StructDecl * structDecl ) {
-                        if ( ! dtorStruct && structDecl->name == "__Destructor" ) {
-                                dtorStruct = structDecl;
-                        }
-                }
-
-                void GenStructMemberCalls::previsit( FunctionDecl * funcDecl ) {
+                void GenStructMemberCalls::premutate( FunctionDecl * funcDecl ) {
                         GuardValue( function );
                         GuardValue( unhandled );
@@ -944 +1032 @@
                         GuardValue( isCtor );
                         GuardValue( structDecl );
-                        errors = SemanticError();  // clear previous errors
+                        errors = SemanticErrorException();  // clear previous errors
 
                         // need to start with fresh sets
                         unhandled.clear();
                         usedUninit.clear();
-
-                        if ( ! dtorStructDestroy && funcDecl->name == "__destroy_Destructor" ) {
-                                dtorStructDestroy = funcDecl;
-                                return;
-                        }
 
                         function = funcDecl;
@@ -965 +1048 @@
                                 if ( structType ) {
                                         structDecl = structType->get_baseStruct();
-                                        if ( structDecl == dtorStruct ) return;
                                         for ( Declaration * member : structDecl->get_members() ) {
                                                 if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
@@ -977 +1059 @@
                 }
 
-                void GenStructMemberCalls::postvisit( FunctionDecl * funcDecl ) {
+                DeclarationWithType * GenStructMemberCalls::postmutate( FunctionDecl * funcDecl ) {
                         // remove the unhandled objects from usedUninit, because a call is inserted
                         // to handle them - only objects that are later constructed are used uninitialized.
@@ -1031 +1113 @@
                                                 Statement * callStmt = stmt.front();
 
-                                                MutatingResolver resolver( indexer );
                                                 try {
-                                                        callStmt->acceptMutator( resolver );
+                                                        callStmt->acceptMutator( *visitor );
                                                         if ( isCtor ) {
-                                                                function->statements->push_front( callStmt );
+                                                                function->get_statements()->push_front( callStmt );
                                                         } else {
                                                                 // destructor statements should be added at the end
-                                                                // function->get_statements()->push_back( callStmt );
-
-                                                                // Destructor _dtor0 = { &b.a1, (void (*)(void *)_destroy_A };
-                                                                std::list< Statement * > stmtsToAdd;
-
-                                                                static UniqueName memberDtorNamer = { "__memberDtor" };
-                                                                assertf( dtorStruct, "builtin __Destructor not found." );
-                                                                assertf( dtorStructDestroy, "builtin __destroy_Destructor not found." );
-
-                                                                Expression * thisExpr = new AddressExpr( new VariableExpr( thisParam ) );
-                                                                Expression * dtorExpr = new VariableExpr( getDtorFunc( thisParam, callStmt, stmtsToAdd ) );
-
-                                                                // cast destructor pointer to void (*)(void *), to silence GCC incompatible pointer warnings
-                                                                FunctionType * dtorFtype = new FunctionType( Type::Qualifiers(), false );
-                                                                dtorFtype->parameters.push_back( ObjectDecl::newObject( "", new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), nullptr ) );
-                                                                Type * dtorType = new PointerType( Type::Qualifiers(), dtorFtype );
-
-                                                                ObjectDecl * destructor = ObjectDecl::newObject( memberDtorNamer.newName(), new StructInstType( Type::Qualifiers(), dtorStruct ), new ListInit( { new SingleInit( thisExpr ), new SingleInit( new CastExpr( dtorExpr, dtorType ) ) } ) );
-                                                                function->statements->push_front( new DeclStmt( destructor ) );
-                                                                destructor->attributes.push_back( new Attribute( "cleanup", { new VariableExpr( dtorStructDestroy ) } ) );
-
-                                                                function->statements->kids.splice( function->statements->kids.begin(), stmtsToAdd );
+                                                                function->get_statements()->push_back( callStmt );
                                                         }
-                                                } catch ( SemanticError & error ) {
+                                                } catch ( SemanticErrorException & error ) {
                                                         emit( funcDecl->location, "in ", CodeGen::genPrettyType( function->get_functionType(), function->get_name() ), ", field ", field->get_name(), " not explicitly ", isCtor ? "constructed" : "destructed",  " and no ", isCtor ? "default constructor" : "destructor", " found" );
                                                 }
@@ -1070 +1130 @@
                                 throw errors;
                         }
+                        return funcDecl;
                 }
 
@@ -1095 +1156 @@
                 }
 
-                void GenStructMemberCalls::previsit( ApplicationExpr * appExpr ) {
+                void GenStructMemberCalls::premutate( ApplicationExpr * appExpr ) {
                         if ( ! checkWarnings( function ) ) {
                                 visit_children = false;
@@ -1102 +1163 @@
 
                         std::string fname = getFunctionName( appExpr );
-                        if ( fname == function->get_name() ) {
+                        if ( fname == function->name ) {
                                 // call to same kind of function
-                                Expression * firstParam = appExpr->get_args().front();
+                                Expression * firstParam = appExpr->args.front();
 
                                 if ( isThisExpression( firstParam, thisParam ) ) {
@@ -1113 +1174 @@
                                         // if first parameter is a member expression on the this parameter,
                                         // then remove the member from unhandled set.
-                                        if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) {
-                                                unhandled.erase( memberExpr->get_member() );
+                                        if ( isThisExpression( memberExpr->aggregate, thisParam ) ) {
+                                                unhandled.erase( memberExpr->member );
                                         }
                                 }
@@ -1120 +1181 @@
                 }
 
-                void GenStructMemberCalls::previsit( MemberExpr * memberExpr ) {
+                void GenStructMemberCalls::premutate( MemberExpr * memberExpr ) {
                         if ( ! checkWarnings( function ) || ! isCtor ) {
                                 visit_children = false;
@@ -1136 +1197 @@
                 template< typename Visitor, typename... Params >
                 void error( Visitor & v, CodeLocation loc, const Params &... params ) {
-                        SemanticError err( toString( params... ) );
-                        err.set_location( loc );
+                        SemanticErrorException err( loc, toString( params... ) );
                         v.errors.append( err );
                 }
@@ -1148 +1208 @@
                 }
 
-                DeclarationWithType * MutatingResolver::mutate( ObjectDecl * objectDecl ) {
-                        // add object to the indexer assumes that there will be no name collisions
-                        // in generated code. If this changes, add mutate methods for entities with
-                        // scope and call {enter,leave}Scope explicitly.
-                        indexer.addId( objectDecl );
-                        return objectDecl;
-                }
-
-                Expression * MutatingResolver::mutate( UntypedExpr * untypedExpr ) {
+                Expression * GenStructMemberCalls::postmutate( UntypedExpr * untypedExpr ) {
                         Expression * newExpr = untypedExpr;
                         ResolvExpr::findVoidExpression( newExpr, indexer );