Changeset db4ecc5

Timestamp:

Apr 14, 2016, 3:22:42 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

70a06f6

Parents:

7eabc25

Message:

add ImplicitCopyCtorExpr? node, implicit copy constructors are inserted into the right places (but there is room for elision)

Location:

src

Files:

• InitTweak/FixInit.cc (modified) (8 diffs)
• InitTweak/RemoveInit.cc (modified) (7 diffs)
• ResolvExpr/Resolver.cc (modified) (5 diffs)
• ResolvExpr/Resolver.h (modified) (2 diffs)
• SynTree/Expression.cc (modified) (3 diffs)
• SynTree/Expression.h (modified) (3 diffs)
• SynTree/Initializer.h (modified) (3 diffs)
• SynTree/Mutator.cc (modified) (2 diffs)
• SynTree/Mutator.h (modified) (2 diffs)
• SynTree/SynTree.h (modified) (2 diffs)
• SynTree/Visitor.cc (modified) (2 diffs)
• SynTree/Visitor.h (modified) (2 diffs)

src/InitTweak/FixInit.cc

@@ -10 +10 @@
 // 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 +17 @@
 #include <list>
 #include "RemoveInit.h"
+#include "ResolvExpr/Resolver.h"
 #include "SynTree/Declaration.h"
 #include "SynTree/Type.h"
@@ -23 +24 @@
 #include "SynTree/Initializer.h"
 #include "SynTree/Mutator.h"
+#include "SymTab/Indexer.h"
 #include "GenPoly/PolyMutator.h"
 
@@ -31 +33 @@
         }
 
+        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 +73 @@
         };
 
+        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 +109 @@
         }
 
-        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 +353 @@
                         insertDtors( list->begin(), list->end(), back_inserter( stmtsToAdd ) );
                 }
-                return returnStmt;
+                return Mutator::mutate( returnStmt );
         }
 
@@ -189 +372 @@
                                 assert( false );
                 }
-                return branchStmt;
+                return Mutator::mutate( branchStmt );
         }
 

src/InitTweak/RemoveInit.cc

@@ -10 +10 @@
 // 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 +42 @@
 
                 RemoveInit();
+
                 virtual ObjectDecl * mutate( ObjectDecl *objDecl );
                 virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
@@ -63 +64 @@
                 CtorDtor() : inFunction( false ) {}
 
-                virtual ObjectDecl * mutate( ObjectDecl * );
+                virtual DeclarationWithType * mutate( ObjectDecl * );
                 virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
                 virtual Declaration* mutate( StructDecl *aggregateDecl );
@@ -71 +72 @@
                 virtual TypeDecl* mutate( TypeDecl *typeDecl );
                 virtual Declaration* mutate( TypedefDecl *typeDecl );
+
+                virtual Type * mutate( FunctionType *funcType );
 
           protected:
@@ -187 +190 @@
         }
 
-        ObjectDecl * CtorDtor::mutate( ObjectDecl * objDecl ) {
+        DeclarationWithType * CtorDtor::mutate( ObjectDecl * objDecl ) {
                 // hands off if designated or if @=
                 if ( tryConstruct( objDecl ) ) {
@@ -233 +236 @@
                         }
                 }
-                return objDecl;
+                return Mutator::mutate( objDecl );
         }
 
@@ -254 +257 @@
         TypeDecl* CtorDtor::mutate( TypeDecl *typeDecl ) { return typeDecl; }
         Declaration* CtorDtor::mutate( TypedefDecl *typeDecl ) { return typeDecl; }
+        Type* CtorDtor::mutate( FunctionType *funcType ) { return funcType; }
 
 } // namespace InitTweak

src/ResolvExpr/Resolver.cc

@@ -10 +10 @@
 // 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 +61 @@
           void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator & );
           void fallbackInit( ConstructorInit * ctorInit );
-
                 std::list< Type * > functionReturn;
                 Type *initContext;
@@ -84 +83 @@
         }
 
+
         namespace {
                 void finishExpr( Expression *expr, const TypeEnvironment &env ) {
@@ -89 +89 @@
                         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 +486 @@
 
         void Resolver::visit( ConstructorInit *ctorInit ) {
-                TypeEnvironment env;
                 try {
                         maybeAccept( ctorInit->get_ctor(), *this );

src/ResolvExpr/Resolver.h

@@ -5 +5 @@
 // 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 +24 @@
         void resolve( std::list< Declaration * > translationUnit );
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer );
+        Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer );
 } // namespace ResolvExpr
 

src/SynTree/Expression.cc

@@ -10 +10 @@
 // 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 +78 @@
 
 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 +434 @@
 }
 
+
+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 ) ) {}
 

src/SynTree/Expression.h

@@ -10 +10 @@
 // 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 +22 @@
 #include "Mutator.h"
 #include "Constant.h"
+#include "Common/UniqueName.h"
 
 /// Expression is the root type for all expressions
@@ -539 +540 @@
 };
 
+/// 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 {

src/SynTree/Initializer.h

@@ -10 +10 @@
 // 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 +58 @@
 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 +83 @@
   public:
         ListInit( const std::list<Initializer*> &initializers,
-                          const std::list<Expression *> &designators, bool maybeConstructed = false );
+                          const std::list<Expression *> &designators = std::list< Expression * >(), bool maybeConstructed = false );
         virtual ~ListInit();
 

src/SynTree/Mutator.cc

@@ -10 +10 @@
 // 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 +331 @@
 }
 
+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 );

src/SynTree/Mutator.h

@@ -10 +10 @@
 // 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 +75 @@
         virtual Expression* mutate( TypeExpr *typeExpr );
         virtual Expression* mutate( AsmExpr *asmExpr );
+        virtual Expression* mutate( ImplicitCopyCtorExpr *impCpCtorExpr );
         virtual Expression* mutate( UntypedValofExpr *valofExpr );
 

src/SynTree/SynTree.h

@@ -10 +10 @@
 // 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 +80 @@
 class TypeExpr;
 class AsmExpr;
+class ImplicitCopyCtorExpr;
 class UntypedValofExpr;
 

src/SynTree/Visitor.cc

@@ -10 +10 @@
 // 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 +279 @@
 }
 
+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 );

src/SynTree/Visitor.h

@@ -10 +10 @@
 // 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 +75 @@
         virtual void visit( TypeExpr *typeExpr );
         virtual void visit( AsmExpr *asmExpr );
+        virtual void visit( ImplicitCopyCtorExpr *impCpCtorExpr );
         virtual void visit( UntypedValofExpr *valofExpr );