Changeset 3403534 for src/InitTweak

Timestamp:

Sep 4, 2016, 10:34:35 PM (9 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

f04a8b81

Parents:

28307be (diff), b16898e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg2:software/cfa/cfa-cc

Location:

src/InitTweak

Files:

• Association.cc (deleted)
• Association.h (deleted)
• BasicInit.cc (deleted)
• BasicInit.h (deleted)
• DeclarationHoister.cc (deleted)
• DeclarationHoister.h (deleted)
• FixInit.cc (modified) (15 diffs)
• GenInit.cc (modified) (9 diffs)
• InitExpander.cc (deleted)
• InitExpander.h (deleted)
• InitModel.cc (deleted)
• InitModel.h (deleted)
• InitTweak.cc (modified) (6 diffs)
• InitTweak.h (modified) (1 diff)
• Mutate.cc (deleted)
• Mutate.h (deleted)
• diet_map.h (deleted)

src/InitTweak/FixInit.cc

@@ -31 +31 @@
 #include "SynTree/Mutator.h"
 #include "SymTab/Indexer.h"
+#include "SymTab/Autogen.h"
 #include "GenPoly/PolyMutator.h"
 #include "SynTree/AddStmtVisitor.h"
@@ -176 +177 @@
                 };
 
-                class WarnStructMembers : public Visitor {
+                class GenStructMemberCalls : public SymTab::Indexer {
                   public:
-                        typedef Visitor Parent;
-                        /// warn if a user-defined constructor or destructor is missing calls for
-                        /// a struct member or if a member is used before constructed
-                        static void warnings( std::list< Declaration * > & translationUnit );
+                        typedef Indexer Parent;
+                        /// generate default/copy ctor and dtor calls for user-defined struct ctor/dtors
+                        /// for any member that is missing a corresponding ctor/dtor call.
+                        /// error if a member is used before constructed
+                        static void generate( std::list< Declaration * > & translationUnit );
 
                         virtual void visit( FunctionDecl * funcDecl );
@@ -188 +190 @@
                         virtual void visit( ApplicationExpr * appExpr );
 
+                        SemanticError errors;
                   private:
                         void handleFirstParam( Expression * firstParam );
+                        template< typename... Params >
+                        void emit( const Params &... params );
 
                         FunctionDecl * function = 0;
-                        std::set< DeclarationWithType * > unhandled;
+                        std::set< DeclarationWithType * > unhandled, usedUninit;
                         ObjectDecl * thisParam = 0;
+                        bool isCtor = false; // true if current function is a constructor
+                        StructDecl * structDecl = 0;
+                };
+
+                // very simple resolver-like mutator class - used to
+                // resolve UntypedExprs that are found within newly
+                // generated constructor/destructor calls
+                class MutatingResolver : public Mutator {
+                  public:
+                        MutatingResolver( SymTab::Indexer & indexer ) : indexer( indexer ) {}
+
+                        virtual DeclarationWithType* mutate( ObjectDecl *objectDecl );
+
+                        virtual Expression* mutate( UntypedExpr *untypedExpr );
+                        private:
+                        SymTab::Indexer & indexer;
                 };
         } // namespace
@@ -209 +230 @@
                 FixCopyCtors::fixCopyCtors( translationUnit );
 
-                WarnStructMembers::warnings( translationUnit );
+                GenStructMemberCalls::generate( translationUnit );
         }
 
@@ -254 +275 @@
                 }
 
-                void WarnStructMembers::warnings( std::list< Declaration * > & translationUnit ) {
-                        if ( true ) { // fix this condition to skip this pass if warnings aren't enabled
-                                WarnStructMembers warner;
-                                acceptAll( translationUnit, warner );
+                void GenStructMemberCalls::generate( std::list< Declaration * > & translationUnit ) {
+                        GenStructMemberCalls warner;
+                        acceptAll( translationUnit, warner );
+
+                        // visitor doesn't throw so that it can collect all errors
+                        if ( ! warner.errors.isEmpty() ) {
+                                throw warner.errors;
                         }
                 }
@@ -528 +552 @@
                                                         FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false );
                                                         dtorCaller->fixUniqueId();
-                                                        dtorCaller->get_statements()->get_kids().push_back( dtorStmt );
+                                                        dtorCaller->get_statements()->push_back( dtorStmt );
 
                                                         // atexit(dtor_atexit);
@@ -543 +567 @@
                                                         // at global scope and there could be multiple function-scoped
                                                         // static variables with the same name in different functions.
+                                                        // Note: it isn't sufficient to modify only the mangleName, because
+                                                        // then subsequent Indexer passes can choke on seeing the object's name
+                                                        // if another object has the same name and type. An unfortunate side-effect
+                                                        // of renaming the object is that subsequent NameExprs may fail to resolve,
+                                                        // but there shouldn't be any remaining past this point.
                                                         static UniqueName staticNamer( "_static_var" );
-                                                        objDecl->set_mangleName( objDecl->get_mangleName() + staticNamer.newName() );
+                                                        objDecl->set_name( objDecl->get_name() + staticNamer.newName() );
+                                                        objDecl->set_mangleName( SymTab::Mangler::mangle( objDecl ) );
 
                                                         objDecl->set_init( NULL );
@@ -709 +739 @@
                 }
 
-                void WarnStructMembers::visit( FunctionDecl * funcDecl ) {
-                        WarnStructMembers old = *this;
-                        *this = WarnStructMembers();
+                void GenStructMemberCalls::visit( FunctionDecl * funcDecl ) {
+                        ValueGuard< FunctionDecl * > oldFunction( funcDecl );
+                        ValueGuard< std::set< DeclarationWithType * > > oldUnhandled( unhandled );
+                        ValueGuard< std::set< DeclarationWithType * > > oldUsedUninit( usedUninit );
+                        ValueGuard< ObjectDecl * > oldThisParam( thisParam );
+                        ValueGuard< bool > oldIsCtor( isCtor );
+                        ValueGuard< StructDecl * > oldStructDecl( structDecl );
+
+                        // need to start with fresh sets
+                        unhandled.clear();
+                        usedUninit.clear();
 
                         function = funcDecl;
-                        if ( checkWarnings( funcDecl ) ) {
-                                FunctionType * type = funcDecl->get_functionType();
+                        isCtor = isConstructor( function->get_name() );
+                        if ( checkWarnings( function ) ) {
+                                FunctionType * type = function->get_functionType();
                                 assert( ! type->get_parameters().empty() );
                                 thisParam = safe_dynamic_cast< ObjectDecl * >( type->get_parameters().front() );
@@ -721 +760 @@
                                 StructInstType * structType = dynamic_cast< StructInstType * >( ptrType->get_base() );
                                 if ( structType ) {
-                                        StructDecl * structDecl = structType->get_baseStruct();
+                                        structDecl = structType->get_baseStruct();
                                         for ( Declaration * member : structDecl->get_members() ) {
                                                 if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
@@ -731 +770 @@
                                 }
                         }
-                        Parent::visit( funcDecl );
-
-                        for ( DeclarationWithType * member : unhandled ) {
-                                // emit a warning for each unhandled member
-                                warn( "in ", CodeGen::genType( function->get_functionType(), function->get_name(), false ), ", member ", member->get_name(), " may not have been ", isConstructor( funcDecl->get_name() ) ? "constructed" : "destructed" );
+                        Parent::visit( function );
+
+                        // remove the unhandled objects from usedUninit, because a call is inserted
+                        // to handle them - only objects that are later constructed are used uninitialized.
+                        std::set< DeclarationWithType * > diff;
+                        std::set_difference( usedUninit.begin(), usedUninit.end(), unhandled.begin(), unhandled.end(), std::inserter( diff, diff.begin() ) );
+                        for ( DeclarationWithType * member : diff ) {
+                                emit( "in ", CodeGen::genType( function->get_functionType(), function->get_name(), false ), ", field ", member->get_name(), " used before being constructed" );
                         }
 
-                        *this = old;
-                }
-
-                void WarnStructMembers::visit( ApplicationExpr * appExpr ) {
+                        if ( ! unhandled.empty() ) {
+                                // need to explicitly re-add function parameters in order to resolve copy constructors
+                                enterScope();
+                                maybeAccept( function->get_functionType(), *this );
+
+                                // need to iterate through members in reverse in order for
+                                // ctor/dtor statements to come out in the right order
+                                for ( Declaration * member : reverseIterate( structDecl->get_members() ) ) {
+                                        DeclarationWithType * field = dynamic_cast< DeclarationWithType * >( member );
+                                        // skip non-DWT members
+                                        if ( ! field ) continue;
+                                        // skip handled members
+                                        if ( ! unhandled.count( field ) ) continue;
+
+                                        // insert and resolve default/copy constructor call for each field that's unhandled
+                                        std::list< Statement * > stmt;
+                                        UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
+                                        deref->get_args().push_back( new VariableExpr( thisParam ) );
+
+                                        Expression * arg2 = 0;
+                                        if ( isCopyConstructor( function ) ) {
+                                                // if copy ctor, need to pass second-param-of-this-function.field
+                                                std::list< DeclarationWithType * > & params = function->get_functionType()->get_parameters();
+                                                assert( params.size() == 2 );
+                                                arg2 = new MemberExpr( field, new VariableExpr( params.back() ) );
+                                        }
+                                        InitExpander srcParam( arg2 );
+                                        SymTab::genImplicitCall( srcParam, new MemberExpr( field, deref ), function->get_name(), back_inserter( stmt ), field, isCtor );
+
+                                        assert( stmt.size() <= 1 );
+                                        if ( stmt.size() == 1 ) {
+                                                Statement * callStmt = stmt.front();
+
+                                                MutatingResolver resolver( *this );
+                                                try {
+                                                        callStmt->acceptMutator( resolver );
+                                                        if ( isCtor ) {
+                                                                function->get_statements()->push_front( callStmt );
+                                                        } else {
+                                                                // destructor statements should be added at the end
+                                                                function->get_statements()->push_back( callStmt );
+                                                        }
+                                                } catch ( SemanticError & error ) {
+                                                        emit( "in ", CodeGen::genType( function->get_functionType(), function->get_name(), false ), ", field ", field->get_name(), " not explicitly ", isCtor ? "constructed" : "destructed",  " and no ", isCtor ? "default constructor" : "destructor", " found" );
+                                                }
+                                        }
+                                }
+                                leaveScope();
+                        }
+                }
+
+                void GenStructMemberCalls::visit( ApplicationExpr * appExpr ) {
                         if ( ! checkWarnings( function ) ) return;
 
@@ -760 +850 @@
                                         handleFirstParam( firstParam );
                                 }
-                        } else if ( fname == "?=?" && isIntrinsicCallExpr( appExpr ) ) {
-                                // forgive use of intrinsic assignment to construct, since instrinsic constructors
-                                // codegen as assignment anyway.
-                                assert( appExpr->get_args().size() == 2 );
-                                handleFirstParam( appExpr->get_args().front() );
                         }
 
@@ -770 +855 @@
                 }
 
-                void WarnStructMembers::handleFirstParam( Expression * firstParam ) {
+                void GenStructMemberCalls::handleFirstParam( Expression * firstParam ) {
                         using namespace std;
                         if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( firstParam ) ) {
@@ -787 +872 @@
                 }
 
-                void WarnStructMembers::visit( MemberExpr * memberExpr ) {
+                void GenStructMemberCalls::visit( MemberExpr * memberExpr ) {
                         if ( ! checkWarnings( function ) ) return;
-                        if ( ! isConstructor( function->get_name() ) ) return;
+                        if ( ! isCtor ) return;
 
                         if ( ApplicationExpr * deref = dynamic_cast< ApplicationExpr * >( memberExpr->get_aggregate() ) ) {
@@ -797 +882 @@
                                                         if ( unhandled.count( memberExpr->get_member() ) ) {
                                                                 // emit a warning because a member was used before it was constructed
-                                                                warn( "in ", CodeGen::genType( function->get_functionType(), function->get_name(), false ), ", member ", memberExpr->get_member()->get_name(), " used before being constructed" );
+                                                                usedUninit.insert( memberExpr->get_member() );
                                                         }
                                                 }
@@ -805 +890 @@
                         Parent::visit( memberExpr );
                 }
+
+                template< typename Visitor, typename... Params >
+                void error( Visitor & v, const Params &... params ) {
+                        v.errors.append( toString( params... ) );
+                }
+
+                template< typename... Params >
+                void GenStructMemberCalls::emit( const Params &... params ) {
+                        // toggle warnings vs. errors here.
+                        // warn( params... );
+                        error( *this, params... );
+                }
+
+                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.
+                        objectDecl->accept( indexer );
+                        return objectDecl;
+                }
+
+                Expression* MutatingResolver::mutate( UntypedExpr *untypedExpr ) {
+                        return safe_dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untypedExpr, indexer ) );
+                }
         } // namespace
 } // namespace InitTweak

src/InitTweak/GenInit.cc

@@ -25 +25 @@
 #include "SynTree/Mutator.h"
 #include "SymTab/Autogen.h"
+#include "SymTab/Mangler.h"
 #include "GenPoly/PolyMutator.h"
 #include "GenPoly/DeclMutator.h"
+#include "GenPoly/ScopedSet.h"
 
 namespace InitTweak {
@@ -55 +57 @@
         class CtorDtor : public GenPoly::PolyMutator {
           public:
+                typedef GenPoly::PolyMutator Parent;
+                using Parent::mutate;
                 /// create constructor and destructor statements for object declarations.
                 /// the actual call statements will be added in after the resolver has run
@@ -65 +69 @@
                 // should not traverse into any of these declarations to find objects
                 // that need to be constructed or destructed
-                virtual Declaration* mutate( StructDecl *aggregateDecl ) { return aggregateDecl; }
+                virtual Declaration* mutate( StructDecl *aggregateDecl );
                 virtual Declaration* mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; }
                 virtual Declaration* mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; }
@@ -74 +78 @@
                 virtual Type * mutate( FunctionType *funcType ) { return funcType; }
 
-          protected:
+                virtual CompoundStmt * mutate( CompoundStmt * compoundStmt );
+
+          private:
+                // set of mangled type names for which a constructor or destructor exists in the current scope.
+                // these types require a ConstructorInit node to be generated, anything else is a POD type and thus
+                // should not have a ConstructorInit generated.
+
+                bool isManaged( ObjectDecl * objDecl ) const ; // determine if object is managed
+                void handleDWT( DeclarationWithType * dwt ); // add type to managed if ctor/dtor
+                GenPoly::ScopedSet< std::string > managedTypes;
+                bool inFunction = false;
         };
 
@@ -142 +156 @@
 
         DeclarationWithType* ReturnFixer::mutate( FunctionDecl *functionDecl ) {
-                std::list<DeclarationWithType*> oldReturnVals = returnVals;
-                std::string oldFuncName = funcName;
+                ValueGuard< std::list<DeclarationWithType*> > oldReturnVals( returnVals );
+                ValueGuard< std::string > oldFuncName( funcName );
 
                 FunctionType * type = functionDecl->get_functionType();
@@ -149 +163 @@
                 funcName = functionDecl->get_name();
                 DeclarationWithType * decl = Mutator::mutate( functionDecl );
-                returnVals = oldReturnVals;
-                funcName = oldFuncName;
                 return decl;
         }
@@ -197 +209 @@
 
         DeclarationWithType * HoistArrayDimension::mutate( FunctionDecl *functionDecl ) {
-                bool oldInFunc = inFunction;
+                ValueGuard< bool > oldInFunc( inFunction );
                 inFunction = true;
                 DeclarationWithType * decl = Parent::mutate( functionDecl );
-                inFunction = oldInFunc;
                 return decl;
         }
@@ -209 +220 @@
         }
 
+        bool CtorDtor::isManaged( ObjectDecl * objDecl ) const {
+                Type * type = objDecl->get_type();
+                while ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
+                        type = at->get_base();
+                }
+                return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end();
+        }
+
+        void CtorDtor::handleDWT( DeclarationWithType * dwt ) {
+                // if this function is a user-defined constructor or destructor, mark down the type as "managed"
+                if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && isCtorDtor( dwt->get_name() ) ) {
+                        std::list< DeclarationWithType * > & params = GenPoly::getFunctionType( dwt->get_type() )->get_parameters();
+                        assert( ! params.empty() );
+                        PointerType * type = safe_dynamic_cast< PointerType * >( params.front()->get_type() );
+                        managedTypes.insert( SymTab::Mangler::mangle( type->get_base() ) );
+                }
+        }
+
         DeclarationWithType * CtorDtor::mutate( ObjectDecl * objDecl ) {
-                // hands off if designated, if @=, or if extern
-                if ( tryConstruct( objDecl ) ) {
+                handleDWT( objDecl );
+                // hands off if @=, extern, builtin, etc.
+                // if global but initializer is not constexpr, always try to construct, since this is not legal C
+                if ( ( tryConstruct( objDecl ) && isManaged( objDecl ) ) || (! inFunction && ! isConstExpr( objDecl->get_init() ) ) ) {
+                        // constructed objects cannot be designated
+                        if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.", objDecl );
+                        // xxx - constructed objects should not have initializers nested too deeply
+
                         // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor
                         // for each constructable object
@@ -241 +276 @@
                         }
                 }
-                return Mutator::mutate( objDecl );
+                return Parent::mutate( objDecl );
         }
 
         DeclarationWithType * CtorDtor::mutate( FunctionDecl *functionDecl ) {
+                ValueGuard< bool > oldInFunc = inFunction;
+                inFunction = true;
+
+                handleDWT( functionDecl );
+
+                managedTypes.beginScope();
+                // go through assertions and recursively add seen ctor/dtors
+                for ( TypeDecl * tyDecl : functionDecl->get_functionType()->get_forall() ) {
+                        for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) {
+                                assertion = assertion->acceptMutator( *this );
+                        }
+                }
                 // parameters should not be constructed and destructed, so don't mutate FunctionType
                 mutateAll( functionDecl->get_oldDecls(), *this );
                 functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
+
+                managedTypes.endScope();
                 return functionDecl;
         }
+
+        Declaration* CtorDtor::mutate( StructDecl *aggregateDecl ) {
+                // don't construct members, but need to take note if there is a managed member,
+                // because that means that this type is also managed
+                for ( Declaration * member : aggregateDecl->get_members() ) {
+                        if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
+                                if ( isManaged( field ) ) {
+                                        managedTypes.insert( SymTab::Mangler::mangle( aggregateDecl ) );
+                                        break;
+                                }
+                        }
+                }
+                return aggregateDecl;
+        }
+
+        CompoundStmt * CtorDtor::mutate( CompoundStmt * compoundStmt ) {
+                managedTypes.beginScope();
+                CompoundStmt * stmt = Parent::mutate( compoundStmt );
+                managedTypes.endScope();
+                return stmt;
+        }
+
 } // namespace InitTweak
 

src/InitTweak/InitTweak.cc

@@ -7 +7 @@
 #include "SynTree/Attribute.h"
 #include "GenPoly/GenPoly.h"
+#include "ResolvExpr/typeops.h"
 
 namespace InitTweak {
@@ -79 +80 @@
         public:
                 ExprImpl( Expression * expr ) : arg( expr ) {}
+
+                ~ExprImpl() { delete arg; }
 
                 virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
@@ -122 +125 @@
 
         void InitExpander::clearArrayIndices() {
+                deleteAll( indices );
                 indices.clear();
         }
@@ -228 +232 @@
                 return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) &&
                         (objDecl->get_init() == NULL ||
-                                ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() )) &&
-                        ! isDesignated( objDecl->get_init() )
+                                ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() ))
                         && objDecl->get_storageClass() != DeclarationNode::Extern;
         }
@@ -387 +390 @@
                 virtual void visit( ApplicationExpr *applicationExpr ) { isConstExpr = false; }
                 virtual void visit( UntypedExpr *untypedExpr ) { isConstExpr = false; }
-                virtual void visit( NameExpr *nameExpr ) { isConstExpr = false; }
-                virtual void visit( CastExpr *castExpr ) { isConstExpr = false; }
+                virtual void visit( NameExpr *nameExpr ) {
+                        // xxx - temporary hack, because 0 and 1 really should be constexprs, even though they technically aren't in Cforall today
+                        if ( nameExpr->get_name() != "0" && nameExpr->get_name() != "1" ) isConstExpr = false;
+                }
+                // virtual void visit( CastExpr *castExpr ) { isConstExpr = false; }
+                virtual void visit( AddressExpr *addressExpr ) {
+                        // address of a variable or member expression is constexpr
+                        Expression * arg = addressExpr->get_arg();
+                        if ( ! dynamic_cast< NameExpr * >( arg) && ! dynamic_cast< VariableExpr * >( arg ) && ! dynamic_cast< MemberExpr * >( arg ) && ! dynamic_cast< UntypedMemberExpr * >( arg ) ) isConstExpr = false;
+                }
                 virtual void visit( LabelAddressExpr *labAddressExpr ) { isConstExpr = false; }
                 virtual void visit( UntypedMemberExpr *memberExpr ) { isConstExpr = false; }
                 virtual void visit( MemberExpr *memberExpr ) { isConstExpr = false; }
                 virtual void visit( VariableExpr *variableExpr ) { isConstExpr = false; }
-                virtual void visit( ConstantExpr *constantExpr ) { /* bottom out */ }
                 // these might be okay?
                 // virtual void visit( SizeofExpr *sizeofExpr );
@@ -436 +446 @@
         bool isDestructor( const std::string & str ) { return str == "^?{}"; }
         bool isCtorDtor( const std::string & str ) { return isConstructor( str ) || isDestructor( str ); }
+
+        FunctionDecl * isCopyConstructor( Declaration * decl ) {
+                FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl );
+                if ( ! function ) return 0;
+                if ( ! isConstructor( function->get_name() ) ) return 0;
+                FunctionType * ftype = function->get_functionType();
+                if ( ftype->get_parameters().size() != 2 ) return 0;
+
+                Type * t1 = ftype->get_parameters().front()->get_type();
+                Type * t2 = ftype->get_parameters().back()->get_type();
+                PointerType * ptrType = dynamic_cast< PointerType * > ( t1 );
+                assert( ptrType );
+
+                if ( ResolvExpr::typesCompatible( ptrType->get_base(), t2, SymTab::Indexer() ) ) {
+                        return function;
+                } else {
+                        return 0;
+                }
+        }
 }

src/InitTweak/InitTweak.h

@@ -29 +29 @@
         bool isDestructor( const std::string & );
         bool isCtorDtor( const std::string & );
+
+        FunctionDecl * isCopyConstructor( Declaration * decl );
 
         /// transform Initializer into an argument list that can be passed to a call expression