Changeset 42f1279c

Timestamp:

Mar 19, 2019, 11:31:06 AM (5 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, persistent-indexer, pthread-emulation, qualifiedEnum

Children:

181a6af

Parents:

fdae913

Message:

Eagerly remove over-ridden generated functions

Location:

src

Files:

• Common/PersistentMap.h (modified) (1 diff)
• SymTab/Indexer.cc (modified) (3 diffs)
• SymTab/Indexer.h (modified) (1 diff)

src/Common/PersistentMap.h

@@ -122 +122 @@
 
 public:
-        using size_type = std::size_t;
-
+        using key_type = typename Base::key_type;
+        using mapped_type = typename Base::mapped_type;
+        using value_type = typename Base::value_type;
+        using size_type = typename Base::size_type;
+        using difference_type = typename Base::difference_type;
         using iterator = typename Base::const_iterator;
 

src/SymTab/Indexer.cc

@@ -22 +22 @@
 #include <unordered_set>           // for unordered_set
 #include <utility>                 // for pair, make_pair, move
+#include <vector>                  // for vector
 
 #include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
@@ -386 +387 @@
         }
 
+        /// gets the base type of the first parameter; decl must be a ctor/dtor/assignment function
+        std::string getOtypeKey( FunctionDecl* function ) {
+                auto& params = function->type->parameters;
+                assert( ! params.empty() );
+                // use base type of pointer, so that qualifiers on the pointer type aren't considered.
+                Type* base = InitTweak::getPointerBase( params.front()->get_type() );
+                assert( base );
+                return Mangler::mangle( base );
+        }
+
+        /// gets the declaration for the function acting on a type specified by otype key, 
+        /// nullptr if none such
+        FunctionDecl * getFunctionForOtype( DeclarationWithType * decl, const std::string& otypeKey ) {
+                FunctionDecl * func = dynamic_cast< FunctionDecl * >( decl );
+                if ( ! func || otypeKey != getOtypeKey( func ) ) return nullptr;
+                return func;
+        }
+
+        bool Indexer::removeSpecialOverrides( 
+                        Indexer::IdData& data, Indexer::MangleTable::Ptr& mangleTable ) {
+                // if a type contains user defined ctor/dtor/assign, then special rules trigger, which 
+                // determinethe set of ctor/dtor/assign that can be used  by the requester. In particular, 
+                // if the user defines a default ctor, then the generated default ctor is unavailable, 
+                // likewise for copy ctor and dtor. If the user defines any ctor/dtor, then no generated 
+                // field ctors are available. If the user defines any ctor then the generated default ctor 
+                // is unavailable (intrinsic default ctor must be overridden exactly). If the user defines 
+                // anything that looks like a copy constructor, then the generated copy constructor is 
+                // unavailable, and likewise for the assignment operator.
+
+                // only relevant on function declarations
+                FunctionDecl * function = dynamic_cast< FunctionDecl * >( data.id );
+                if ( ! function ) return true;
+                // only need to perform this check for constructors, destructors, and assignment functions
+                if ( ! CodeGen::isCtorDtorAssign( data.id->name ) ) return true;
+
+                // set up information for this type
+                bool dataIsUserDefinedFunc = ! LinkageSpec::isOverridable( function->linkage );
+                bool dataIsCopyFunc = InitTweak::isCopyFunction( function, function->name );
+                std::string dataOtypeKey = getOtypeKey( function );
+
+                if ( dataIsUserDefinedFunc && dataIsCopyFunc ) {
+                        // this is a user-defined copy function
+                        // if this is the first such, delete/remove non-user-defined overloads as needed
+                        std::vector< std::string > removed;
+                        std::vector< MangleTable::value_type > deleted;
+                        bool alreadyUserDefinedFunc = false;
+                        
+                        for ( const auto& entry : *mangleTable ) {
+                                // skip decls that aren't functions or are for the wrong type
+                                FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
+                                if ( ! decl ) continue;
+
+                                bool isCopyFunc = InitTweak::isCopyFunction( decl, decl->name );
+                                if ( ! LinkageSpec::isOverridable( decl->linkage ) ) {
+                                        // matching user-defined function
+                                        if ( isCopyFunc ) {
+                                                // mutation already performed, return early
+                                                return true;
+                                        } else {
+                                                // note that non-copy deletions already performed
+                                                alreadyUserDefinedFunc = true;
+                                        }
+                                } else {
+                                        // non-user-defined function; mark for deletion/removal as appropriate
+                                        if ( isCopyFunc ) {
+                                                removed.push_back( entry.first );
+                                        } else if ( ! alreadyUserDefinedFunc ) {
+                                                deleted.push_back( entry );
+                                        }
+                                }
+                        }
+
+                        // perform removals from mangle table, and deletions if necessary
+                        for ( const auto& key : removed ) {
+                                mangleTable = mangleTable->erase( key );
+                        }
+                        if ( ! alreadyUserDefinedFunc ) for ( const auto& entry : deleted ) {
+                                mangleTable = mangleTable->set( entry.first, IdData{ entry.second, function } );
+                        }
+                } else if ( dataIsUserDefinedFunc ) {
+                        // this is a user-defined non-copy function
+                        // if this is the first user-defined function, delete non-user-defined overloads
+                        std::vector< MangleTable::value_type > deleted;
+                        
+                        for ( const auto& entry : *mangleTable ) {
+                                // skip decls that aren't functions or are for the wrong type
+                                FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
+                                if ( ! decl ) continue;
+
+                                // exit early if already a matching user-defined function;
+                                // earlier function will have mutated table
+                                if ( ! LinkageSpec::isOverridable( decl->linkage ) ) return true;
+
+                                // skip mutating intrinsic functions
+                                if ( decl->linkage == LinkageSpec::Intrinsic ) continue;
+
+                                // user-defined non-copy functions do not override copy functions
+                                if ( InitTweak::isCopyFunction( decl, decl->name ) ) continue;
+
+                                // this function to be deleted after mangleTable iteration is complete
+                                deleted.push_back( entry );
+                        }
+
+                        // mark deletions to update mangle table
+                        // this needs to be a separate loop because of iterator invalidation
+                        for ( const auto& entry : deleted ) {
+                                mangleTable = mangleTable->set( entry.first, IdData{ entry.second, function } );
+                        }
+                } else if ( function->linkage != LinkageSpec::Intrinsic ) {
+                        // this is an overridable generated function
+                        // if there already exists a matching user-defined function, delete this appropriately
+                        for ( const auto& entry : *mangleTable ) {
+                                // skip decls that aren't functions or are for the wrong type
+                                FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
+                                if ( ! decl ) continue;
+
+                                // skip non-user-defined functions
+                                if ( LinkageSpec::isOverridable( decl->linkage ) ) continue;
+
+                                if ( dataIsCopyFunc ) {
+                                        // remove current function if exists a user-defined copy function
+                                        // since the signatures for copy functions don't need to match exactly, using 
+                                        // a delete statement is the wrong approach
+                                        if ( InitTweak::isCopyFunction( decl, decl->name ) ) return false;
+                                } else {
+                                        // mark current function deleted by first user-defined function found
+                                        data.deleteStmt = decl;
+                                        return true;
+                                }
+                        }
+                }
+                
+                // nothing (more) to fix, return true
+                return true;
+        }
+
         void Indexer::addId( 
                         DeclarationWithType *decl, OnConflict handleConflicts, Expression * baseExpr, 
                         BaseSyntaxNode * deleteStmt ) {
                 ++*stats().add_calls;
-                if ( decl->name == "" ) return;
+                const std::string &name = decl->name;
+                if ( name == "" ) return;
                 
-                const std::string &name = decl->name;
                 std::string mangleName;
                 if ( LinkageSpec::isOverridable( decl->linkage ) ) {
@@ -454 +591 @@
                 // add/overwrite with new identifier
                 lazyInitScope();
+                IdData data{ decl, baseExpr, deleteStmt, scope };
+                if ( ! removeSpecialOverrides( data, mangleTable ) ) return;
                 *stats().map_mutations += 2;
-                idTable = idTable->set( 
-                        name,
-                        mangleTable->set( mangleName, IdData{ decl, baseExpr, deleteStmt, scope } ) );
+                idTable = idTable->set( name, mangleTable->set( mangleName, std::move(data) ) );
         }
 

src/SymTab/Indexer.h

@@ -144 +144 @@
                 /// Removes matching autogenerated constructors and destructors
                 /// so that they will not be selected
-                /// void removeSpecialOverrides( FunctionDecl *decl );
                 void removeSpecialOverrides( const std::string &id, std::list< IdData > & out ) const;
+
+                /// Removes matching autogenerated constructors and destructors so that they will not be 
+                /// selected. If returns false, passed decl should not be added.
+                bool removeSpecialOverrides( IdData& decl, MangleTable::Ptr& mangleTable );
 
                 /// Options for handling identifier conflicts