Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision 7eabc2591eb5260bf1b5a508a1d6153f617eae8a) +++ src/InitTweak/FixInit.cc (revision db4ecc5dc5f63e878081bdb8834e09944e3d08b7) @@ -10,5 +10,5 @@ // Created On : Wed Jan 13 16:29:30 2016 // Last Modified By : Rob Schluntz -// Last Modified On : Thu Mar 31 13:54:58 2016 +// Last Modified On : Thu Apr 14 15:19:11 2016 // Update Count : 30 // @@ -17,4 +17,5 @@ #include #include "RemoveInit.h" +#include "ResolvExpr/Resolver.h" #include "SynTree/Declaration.h" #include "SynTree/Type.h" @@ -23,4 +24,5 @@ #include "SynTree/Initializer.h" #include "SynTree/Mutator.h" +#include "SymTab/Indexer.h" #include "GenPoly/PolyMutator.h" @@ -31,9 +33,34 @@ } + class InsertImplicitCalls : public Mutator { + public: + /// wrap function application expressions as ImplicitCopyCtorExpr nodes + /// so that it is easy to identify which function calls need their parameters + /// to be copy constructed + static void insert( std::list< Declaration * > & translationUnit ); + + virtual Expression * mutate( ApplicationExpr * appExpr ); + }; + + class ResolveCopyCtors : public SymTab::Indexer { + public: + /// generate temporary ObjectDecls for each argument and return value of each + /// ImplicitCopyCtorExpr, generate/resolve copy construction expressions for each, + /// and generate/resolve destructors for both arguments and return value temporaries + static void resolveImplicitCalls( std::list< Declaration * > & translationUnit ); + + virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ); + + /// create and resolve ctor/dtor expression: fname(var, [cpArg]) + ApplicationExpr * makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg = NULL ); + }; + class FixInit : public GenPoly::PolyMutator { public: + /// expand each object declaration to use its constructor after it is declared. + /// insert destructor calls at the appropriate places static void fixInitializers( std::list< Declaration * > &translationUnit ); - virtual ObjectDecl * mutate( ObjectDecl *objDecl ); + virtual DeclarationWithType * mutate( ObjectDecl *objDecl ); virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ); @@ -46,6 +73,33 @@ }; + class FixCopyCtors : public GenPoly::PolyMutator { + public: + /// expand ImplicitCopyCtorExpr nodes into the temporary declarations, copy constructors, + /// call expression, and destructors + static void fixCopyCtors( std::list< Declaration * > &translationUnit ); + + virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ); + + private: + // stack of list of statements - used to differentiate scopes + std::list< std::list< Statement * > > dtorStmts; + }; + void fix( std::list< Declaration * > & translationUnit ) { + InsertImplicitCalls::insert( translationUnit ); + ResolveCopyCtors::resolveImplicitCalls( translationUnit ); FixInit::fixInitializers( translationUnit ); + // FixCopyCtors must happen after FixInit, so that destructors are placed correctly + FixCopyCtors::fixCopyCtors( translationUnit ); + } + + void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit ) { + InsertImplicitCalls inserter; + mutateAll( translationUnit, inserter ); + } + + void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit ) { + ResolveCopyCtors resolver; + acceptAll( translationUnit, resolver ); } @@ -55,5 +109,134 @@ } - ObjectDecl *FixInit::mutate( ObjectDecl *objDecl ) { + void FixCopyCtors::fixCopyCtors( std::list< Declaration * > & translationUnit ) { + FixCopyCtors fixer; + mutateAll( translationUnit, fixer ); + } + + Expression * InsertImplicitCalls::mutate( ApplicationExpr * appExpr ) { + if ( VariableExpr * function = dynamic_cast< VariableExpr * > ( appExpr->get_function() ) ) { + if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) { + // optimization: don't need to copy construct in order to call intrinsic functions + return appExpr; + } else if ( FunctionDecl * func = dynamic_cast< FunctionDecl * > ( function->get_var() ) ) { + // if ( ) + // // optimization: don't need to copy construct in order to call a copy constructor + // return appExpr; + } + } + // wrap each function call so that it is easy to identify nodes that have to be copy constructed + appExpr = dynamic_cast< ApplicationExpr * >( Mutator::mutate( appExpr ) ); + assert( appExpr ); + return new ImplicitCopyCtorExpr( appExpr ); + } + + ApplicationExpr * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) { + assert( var ); + UntypedExpr * untyped = new UntypedExpr( new NameExpr( fname ) ); + untyped->get_args().push_back( new AddressExpr( new VariableExpr( var ) ) ); + if (cpArg) untyped->get_args().push_back( cpArg ); + + // resolve copy constructor + // should only be one alternative for copy ctor and dtor expressions, since + // all arguments are fixed (VariableExpr and already resolved expression) + ApplicationExpr * resolved = dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untyped, *this ) ); + + assert( resolved ); + delete untyped; + return resolved; + } + + void ResolveCopyCtors::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) { + static UniqueName tempNamer("_tmp_cp"); + static UniqueName retNamer("_tmp_cp_ret"); + + // resolve function call + Expression * newExpr = ResolvExpr::findVoidExpression( impCpCtorExpr->get_callExpr(), *this ); + delete impCpCtorExpr->get_callExpr(); + ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( newExpr ); + assert( appExpr ); + impCpCtorExpr->set_callExpr( appExpr ); + + // take each argument and attempt to copy construct it. + for ( Expression * & arg : appExpr->get_args() ) { + // xxx - need to handle tuple arguments + assert( ! arg->get_results().empty() ); + ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, arg->get_results().front()->clone(), 0 ); + + // create and resolve copy constructor + ApplicationExpr * cpCtor = makeCtorDtor( "?{}", tmp, arg ); + + // if the chosen constructor is intrinsic, the copy is unnecessary, so + // don't create the temporary and don't call the copy constructor + VariableExpr * function = dynamic_cast< VariableExpr * >( cpCtor->get_function() ); + assert( function ); + if ( function->get_var()->get_linkage() != LinkageSpec::Intrinsic ) { + // replace argument to function call with temporary + arg = new VariableExpr( tmp ); + impCpCtorExpr->get_tempDecls().push_back( tmp ); + impCpCtorExpr->get_copyCtors().push_back( cpCtor ); + impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", tmp ) ); + } + } + + // each return value from the call needs to be connected with an ObjectDecl + // at the call site, which is initialized with the return value and is destructed + // later + // xxx - handle multiple return values + for ( Type * result : appExpr->get_results() ) { + ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result->clone(), new SingleInit( impCpCtorExpr->get_callExpr() ) ); + impCpCtorExpr->get_returnDecls().push_back( ret ); + impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) ); + } + } + + + Expression * FixCopyCtors::mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) { + impCpCtorExpr = dynamic_cast< ImplicitCopyCtorExpr * >( Mutator::mutate( impCpCtorExpr ) ); + assert( impCpCtorExpr ); + std::cerr << "Running FixCopyCtors on implicit copy ctor..." << std::endl; + + std::list< Expression * > & copyCtors = impCpCtorExpr->get_copyCtors(); + std::list< ObjectDecl * > & tempDecls = impCpCtorExpr->get_tempDecls(); + std::list< ObjectDecl * > & returnDecls = impCpCtorExpr->get_returnDecls(); + std::list< Expression * > & dtors = impCpCtorExpr->get_dtors(); + + // add all temporary declarations and their constructors + for ( ObjectDecl * obj : tempDecls ) { + assert( ! copyCtors.empty() ); + stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) ); + stmtsToAdd.push_back( new ExprStmt( noLabels, copyCtors.front() ) ); + copyCtors.pop_front(); + } + + // add destructors after current statement + for ( Expression * dtor : dtors ) { + stmtsToAddAfter.push_back( new ExprStmt( noLabels, dtor ) ); + } + + // xxx - update to work with multiple return values + ObjectDecl * returnDecl = returnDecls.empty() ? NULL : returnDecls.front(); + + // xxx - some of these aren't necessary, and can be removed once this is stable + copyCtors.clear(); + dtors.clear(); + tempDecls.clear(); + returnDecls.clear(); + + if ( returnDecl ) { + // call is currently attached to first returnDecl + stmtsToAdd.push_back( new DeclStmt( noLabels, returnDecl ) ); + return new VariableExpr( returnDecl ); + } else { + // add call expression - if no return values, can call directly + return impCpCtorExpr->get_callExpr(); + } + } + + DeclarationWithType *FixInit::mutate( ObjectDecl *objDecl ) { + // first recursively handle pieces of ObjectDecl so that they aren't missed by other visitors + // when the init is removed from the ObjectDecl + objDecl = dynamic_cast< ObjectDecl * >( Mutator::mutate( objDecl ) ); + 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 @@ -170,5 +353,5 @@ insertDtors( list->begin(), list->end(), back_inserter( stmtsToAdd ) ); } - return returnStmt; + return Mutator::mutate( returnStmt ); } @@ -189,5 +372,5 @@ assert( false ); } - return branchStmt; + return Mutator::mutate( branchStmt ); } Index: src/InitTweak/RemoveInit.cc =================================================================== --- src/InitTweak/RemoveInit.cc (revision 7eabc2591eb5260bf1b5a508a1d6153f617eae8a) +++ src/InitTweak/RemoveInit.cc (revision db4ecc5dc5f63e878081bdb8834e09944e3d08b7) @@ -10,5 +10,5 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Rob Schluntz -// Last Modified On : Mon Apr 11 17:28:43 2016 +// Last Modified On : Thu Apr 14 15:09:36 2016 // Update Count : 166 // @@ -42,4 +42,5 @@ RemoveInit(); + virtual ObjectDecl * mutate( ObjectDecl *objDecl ); virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ); @@ -63,5 +64,5 @@ CtorDtor() : inFunction( false ) {} - virtual ObjectDecl * mutate( ObjectDecl * ); + virtual DeclarationWithType * mutate( ObjectDecl * ); virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ); virtual Declaration* mutate( StructDecl *aggregateDecl ); @@ -71,4 +72,6 @@ virtual TypeDecl* mutate( TypeDecl *typeDecl ); virtual Declaration* mutate( TypedefDecl *typeDecl ); + + virtual Type * mutate( FunctionType *funcType ); protected: @@ -187,5 +190,5 @@ } - ObjectDecl * CtorDtor::mutate( ObjectDecl * objDecl ) { + DeclarationWithType * CtorDtor::mutate( ObjectDecl * objDecl ) { // hands off if designated or if @= if ( tryConstruct( objDecl ) ) { @@ -233,5 +236,5 @@ } } - return objDecl; + return Mutator::mutate( objDecl ); } @@ -254,4 +257,5 @@ TypeDecl* CtorDtor::mutate( TypeDecl *typeDecl ) { return typeDecl; } Declaration* CtorDtor::mutate( TypedefDecl *typeDecl ) { return typeDecl; } + Type* CtorDtor::mutate( FunctionType *funcType ) { return funcType; } } // namespace InitTweak Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision 7eabc2591eb5260bf1b5a508a1d6153f617eae8a) +++ src/ResolvExpr/Resolver.cc (revision db4ecc5dc5f63e878081bdb8834e09944e3d08b7) @@ -10,5 +10,5 @@ // Created On : Sun May 17 12:17:01 2015 // Last Modified By : Rob Schluntz -// Last Modified On : Mon Apr 04 17:11:54 2016 +// Last Modified On : Thu Apr 14 11:18:12 2016 // Update Count : 203 // @@ -61,5 +61,4 @@ void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator & ); void fallbackInit( ConstructorInit * ctorInit ); - std::list< Type * > functionReturn; Type *initContext; @@ -84,4 +83,5 @@ } + namespace { void finishExpr( Expression *expr, const TypeEnvironment &env ) { @@ -89,13 +89,15 @@ env.makeSubstitution( *expr->get_env() ); } - - Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer ) { - global_renamer.reset(); - TypeEnvironment env; - Expression *newExpr = resolveInVoidContext( untyped, indexer, env ); - finishExpr( newExpr, env ); - return newExpr; - } - + } // namespace + + Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer ) { + global_renamer.reset(); + TypeEnvironment env; + Expression *newExpr = resolveInVoidContext( untyped, indexer, env ); + finishExpr( newExpr, env ); + return newExpr; + } + + namespace { Expression *findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) { TypeEnvironment env; @@ -484,5 +486,4 @@ void Resolver::visit( ConstructorInit *ctorInit ) { - TypeEnvironment env; try { maybeAccept( ctorInit->get_ctor(), *this ); Index: src/ResolvExpr/Resolver.h =================================================================== --- src/ResolvExpr/Resolver.h (revision 7eabc2591eb5260bf1b5a508a1d6153f617eae8a) +++ src/ResolvExpr/Resolver.h (revision db4ecc5dc5f63e878081bdb8834e09944e3d08b7) @@ -5,10 +5,10 @@ // file "LICENCE" distributed with Cforall. // -// Resolver.h -- +// Resolver.h -- // // Author : Richard C. Bilson // Created On : Sun May 17 12:18:34 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sun May 17 12:19:32 2015 +// Last Modified By : Rob Schluntz +// Last Modified On : Thu Apr 14 15:06:53 2016 // Update Count : 2 // @@ -24,4 +24,5 @@ void resolve( std::list< Declaration * > translationUnit ); Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer ); + Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer ); } // namespace ResolvExpr Index: src/SynTree/Expression.cc =================================================================== --- src/SynTree/Expression.cc (revision 7eabc2591eb5260bf1b5a508a1d6153f617eae8a) +++ src/SynTree/Expression.cc (revision db4ecc5dc5f63e878081bdb8834e09944e3d08b7) @@ -10,5 +10,5 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Rob Schluntz -// Last Modified On : Wed Dec 09 14:10:29 2015 +// Last Modified On : Thu Apr 14 13:02:28 2016 // Update Count : 34 // @@ -78,4 +78,6 @@ VariableExpr::VariableExpr( DeclarationWithType *_var, Expression *_aname ) : Expression( _aname ), var( _var ) { + assert( var ); + assert( var->get_type() ); add_result( var->get_type()->clone() ); for ( std::list< Type* >::iterator i = get_results().begin(); i != get_results().end(); ++i ) { @@ -432,4 +434,37 @@ } + +ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( ApplicationExpr * callExpr ) : callExpr( callExpr ) { + assert( callExpr ); + cloneAll( callExpr->get_results(), results ); +} + +ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other ) : Expression( other ), callExpr( maybeClone( other.callExpr ) ) { + cloneAll( other.results, results ); + cloneAll( other.copyCtors, copyCtors ); + cloneAll( other.tempDecls, tempDecls ); + cloneAll( other.returnDecls, returnDecls ); + cloneAll( other.dtors, dtors ); +} + +ImplicitCopyCtorExpr::~ImplicitCopyCtorExpr() { + delete callExpr; + deleteAll( copyCtors ); + deleteAll( tempDecls ); + deleteAll( returnDecls ); + deleteAll( dtors ); +} + +void ImplicitCopyCtorExpr::print( std::ostream &os, int indent ) const { + os << std::string( indent, ' ' ) << "Implicit Copy Constructor Expression: " << std::endl; + assert( callExpr ); + callExpr->print( os, indent + 2 ); + os << std::endl << std::string( indent, ' ' ) << "with temporaries:" << std::endl; + printAll(tempDecls, os, indent+2); + os << std::endl << std::string( indent, ' ' ) << "with copyCtors:" << std::endl; + printAll(copyCtors, os, indent+2); + Expression::print( os, indent ); +} + UntypedValofExpr::UntypedValofExpr( const UntypedValofExpr & other ) : Expression( other ), body ( maybeClone( other.body ) ) {} Index: src/SynTree/Expression.h =================================================================== --- src/SynTree/Expression.h (revision 7eabc2591eb5260bf1b5a508a1d6153f617eae8a) +++ src/SynTree/Expression.h (revision db4ecc5dc5f63e878081bdb8834e09944e3d08b7) @@ -10,5 +10,5 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Rob Schluntz -// Last Modified On : Wed Dec 09 14:10:21 2015 +// Last Modified On : Thu Apr 14 12:04:58 2016 // Update Count : 19 // @@ -22,4 +22,5 @@ #include "Mutator.h" #include "Constant.h" +#include "Common/UniqueName.h" /// Expression is the root type for all expressions @@ -539,4 +540,39 @@ }; +/// ImplicitCopyCtorExpr represents the application of a function to a set of parameters, +/// along with a set of copy constructor calls, one for each argument. +class ImplicitCopyCtorExpr : public Expression { +public: + ImplicitCopyCtorExpr( ApplicationExpr * callExpr ); + ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other ); + virtual ~ImplicitCopyCtorExpr(); + + ApplicationExpr *get_callExpr() const { return callExpr; } + void set_callExpr( ApplicationExpr *newValue ) { callExpr = newValue; } + + std::list< Expression * > & get_copyCtors() { return copyCtors; } + void set_copyCtors( std::list< Expression * > newValue ) { copyCtors = newValue; } + + std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; } + void set_tempDecls( std::list< ObjectDecl * > newValue ) { tempDecls = newValue; } + + std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; } + void set_returnDecls( std::list< ObjectDecl * > newValue ) { returnDecls = newValue; } + + std::list< Expression * > & get_dtors() { return dtors; } + void set_dtors( std::list< Expression * > newValue ) { dtors = newValue; } + + virtual ImplicitCopyCtorExpr *clone() const { return new ImplicitCopyCtorExpr( *this ); } + virtual void accept( Visitor &v ) { v.visit( this ); } + virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); } + virtual void print( std::ostream &os, int indent = 0 ) const; + private: + ApplicationExpr * callExpr; + std::list< Expression * > copyCtors; + std::list< ObjectDecl * > tempDecls; + std::list< ObjectDecl * > returnDecls; + std::list< Expression * > dtors; +}; + /// ValofExpr represents a GCC 'lambda expression' class UntypedValofExpr : public Expression { Index: src/SynTree/Initializer.h =================================================================== --- src/SynTree/Initializer.h (revision 7eabc2591eb5260bf1b5a508a1d6153f617eae8a) +++ src/SynTree/Initializer.h (revision db4ecc5dc5f63e878081bdb8834e09944e3d08b7) @@ -10,5 +10,5 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Rob Schluntz -// Last Modified On : Mon Apr 11 17:35:30 2016 +// Last Modified On : Tue Apr 12 13:49:13 2016 // Update Count : 19 // @@ -58,5 +58,5 @@ class SingleInit : public Initializer { public: - SingleInit( Expression *value, const std::list< Expression *> &designators, bool maybeConstructed = false ); + SingleInit( Expression *value, const std::list< Expression *> &designators = std::list< Expression * >(), bool maybeConstructed = false ); SingleInit( const SingleInit &other ); virtual ~SingleInit(); @@ -83,5 +83,5 @@ public: ListInit( const std::list &initializers, - const std::list &designators, bool maybeConstructed = false ); + const std::list &designators = std::list< Expression * >(), bool maybeConstructed = false ); virtual ~ListInit(); Index: src/SynTree/Mutator.cc =================================================================== --- src/SynTree/Mutator.cc (revision 7eabc2591eb5260bf1b5a508a1d6153f617eae8a) +++ src/SynTree/Mutator.cc (revision db4ecc5dc5f63e878081bdb8834e09944e3d08b7) @@ -10,5 +10,5 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Rob Schluntz -// Last Modified On : Mon Apr 04 17:14:20 2016 +// Last Modified On : Fri Apr 08 14:01:47 2016 // Update Count : 15 // @@ -331,4 +331,11 @@ } +Expression* Mutator::mutate( ImplicitCopyCtorExpr *impCpCtorExpr ) { + impCpCtorExpr->set_callExpr( maybeMutate( impCpCtorExpr->get_callExpr(), *this ) ); + mutateAll( impCpCtorExpr->get_copyCtors(), *this ); + mutateAll( impCpCtorExpr->get_tempDecls(), *this ); + return impCpCtorExpr; +} + Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) { mutateAll( valofExpr->get_results(), *this ); Index: src/SynTree/Mutator.h =================================================================== --- src/SynTree/Mutator.h (revision 7eabc2591eb5260bf1b5a508a1d6153f617eae8a) +++ src/SynTree/Mutator.h (revision db4ecc5dc5f63e878081bdb8834e09944e3d08b7) @@ -10,5 +10,5 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Rob Schluntz -// Last Modified On : Mon Apr 04 17:14:44 2016 +// Last Modified On : Fri Apr 08 13:22:04 2016 // Update Count : 9 // @@ -75,4 +75,5 @@ virtual Expression* mutate( TypeExpr *typeExpr ); virtual Expression* mutate( AsmExpr *asmExpr ); + virtual Expression* mutate( ImplicitCopyCtorExpr *impCpCtorExpr ); virtual Expression* mutate( UntypedValofExpr *valofExpr ); Index: src/SynTree/SynTree.h =================================================================== --- src/SynTree/SynTree.h (revision 7eabc2591eb5260bf1b5a508a1d6153f617eae8a) +++ src/SynTree/SynTree.h (revision db4ecc5dc5f63e878081bdb8834e09944e3d08b7) @@ -10,5 +10,5 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Rob Schluntz -// Last Modified On : Mon Apr 04 17:16:09 2016 +// Last Modified On : Fri Apr 08 13:49:47 2016 // Update Count : 4 // @@ -80,4 +80,5 @@ class TypeExpr; class AsmExpr; +class ImplicitCopyCtorExpr; class UntypedValofExpr; Index: src/SynTree/Visitor.cc =================================================================== --- src/SynTree/Visitor.cc (revision 7eabc2591eb5260bf1b5a508a1d6153f617eae8a) +++ src/SynTree/Visitor.cc (revision db4ecc5dc5f63e878081bdb8834e09944e3d08b7) @@ -10,5 +10,5 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Rob Schluntz -// Last Modified On : Mon Apr 04 17:16:25 2016 +// Last Modified On : Fri Apr 08 13:53:21 2016 // Update Count : 18 // @@ -279,4 +279,10 @@ } +void Visitor::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) { + maybeAccept( impCpCtorExpr->get_callExpr(), *this ); + acceptAll( impCpCtorExpr->get_copyCtors(), *this ); + acceptAll( impCpCtorExpr->get_tempDecls(), *this ); +} + void Visitor::visit( UntypedValofExpr *valofExpr ) { acceptAll( valofExpr->get_results(), *this ); Index: src/SynTree/Visitor.h =================================================================== --- src/SynTree/Visitor.h (revision 7eabc2591eb5260bf1b5a508a1d6153f617eae8a) +++ src/SynTree/Visitor.h (revision db4ecc5dc5f63e878081bdb8834e09944e3d08b7) @@ -10,5 +10,5 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Rob Schluntz -// Last Modified On : Mon Apr 04 17:16:36 2016 +// Last Modified On : Fri Apr 08 13:26:31 2016 // Update Count : 6 // @@ -75,4 +75,5 @@ virtual void visit( TypeExpr *typeExpr ); virtual void visit( AsmExpr *asmExpr ); + virtual void visit( ImplicitCopyCtorExpr *impCpCtorExpr ); virtual void visit( UntypedValofExpr *valofExpr );