Changes in src/SymTab/Autogen.cc [837ce06:e220391]

File:

• src/SymTab/Autogen.cc (modified) (5 diffs)

src/SymTab/Autogen.cc

@@ -46 +46 @@
         /// Data used to generate functions generically. Specifically, the name of the generated function and a function which generates the routine protoype
         struct FuncData {
-                typedef FunctionType * (*TypeGen)( Type *, bool );
+                typedef FunctionType * (*TypeGen)( Type * );
                 FuncData( const std::string & fname, const TypeGen & genType ) : fname( fname ), genType( genType ) {}
                 std::string fname;
@@ -236 +236 @@
 
         /// given type T, generate type of default ctor/dtor, i.e. function type void (*) (T *)
-        FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic ) {
+        FunctionType * genDefaultType( Type * paramType ) {
+                const auto & typeParams = getGenericParams( paramType );
                 FunctionType *ftype = new FunctionType( Type::Qualifiers(), false );
-                if ( maybePolymorphic ) {
-                        // only copy in
-                        const auto & typeParams = getGenericParams( paramType );
-                        cloneAll( typeParams, ftype->forall );
-                }
+                cloneAll( typeParams, ftype->forall );
                 ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), paramType->clone() ), nullptr );
                 ftype->parameters.push_back( dstParam );
@@ -249 +246 @@
 
         /// given type T, generate type of copy ctor, i.e. function type void (*) (T *, T)
-        FunctionType * genCopyType( Type * paramType, bool maybePolymorphic ) {
-                FunctionType *ftype = genDefaultType( paramType, maybePolymorphic );
+        FunctionType * genCopyType( Type * paramType ) {
+                FunctionType *ftype = genDefaultType( paramType );
                 ObjectDecl *srcParam = new ObjectDecl( "_src", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
                 ftype->parameters.push_back( srcParam );
@@ -257 +254 @@
 
         /// given type T, generate type of assignment, i.e. function type T (*) (T *, T)
-        FunctionType * genAssignType( Type * paramType, bool maybePolymorphic ) {
-                FunctionType *ftype = genCopyType( paramType, maybePolymorphic );
+        FunctionType * genAssignType( Type * paramType ) {
+                FunctionType *ftype = genCopyType( paramType );
                 ObjectDecl *returnVal = new ObjectDecl( "_ret", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
                 ftype->returnVals.push_back( returnVal );
@@ -314 +311 @@
         void FuncGenerator::generatePrototypes( std::list< FunctionDecl * > & newFuncs ) {
                 bool concurrent_type = isConcurrentType();
-                for ( const FuncData & data : data ) {
+                for ( const FuncData & d : data ) {
                         // generate a function (?{}, ?=?, ^?{}) based on the current FuncData.
-                        FunctionType * ftype = data.genType( type, true );
+                        FunctionType * ftype = d.genType( type );
 
                         // destructor for concurrent type must be mutex
-                        if ( concurrent_type && CodeGen::isDestructor( data.fname ) ) {
+                        if ( concurrent_type && CodeGen::isDestructor( d.fname ) ) {
                                 ftype->parameters.front()->get_type()->set_mutex( true );
                         }
 
-                        newFuncs.push_back( genFunc( data.fname, ftype, functionNesting ) );
+                        newFuncs.push_back( genFunc( d.fname, ftype, functionNesting ) );
                 }
         }