Changes in src/SymTab/Indexer.cc [6a57da5:bed4c63e]

File:

• src/SymTab/Indexer.cc (modified) (6 diffs)

src/SymTab/Indexer.cc

@@ -19 +19 @@
 #include <typeinfo>
 #include <unordered_map>
-#include <unordered_set>
 #include <utility>
 
@@ -436 +435 @@
 
         void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &out ) const {
-                std::unordered_set< std::string > foundMangleNames;
+                if ( ! tables ) return;
+
+                IdTable::const_iterator decls = tables->idTable.find( id );
+                if ( decls != tables->idTable.end() ) {
+                        const MangleTable &mangleTable = decls->second;
+                        for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
+                                out.push_back( decl->second );
+                        }
+                }
                 
-                Indexer::Impl *searchTables = tables;
-                while ( searchTables ) {
-
-                        IdTable::const_iterator decls = searchTables->idTable.find( id );
-                        if ( decls != searchTables->idTable.end() ) {
-                                const MangleTable &mangleTable = decls->second;
-                                for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
-                                        // mark the mangled name as found, skipping this insertion if a declaration for that name has already been found
-                                        if ( foundMangleNames.insert( decl->first ).second == false ) continue;
-                                        
-                                        out.push_back( decl->second );
-                                }
-                        }
-                        
-                        // get declarations from base indexers
-                        searchTables = searchTables->base.tables;
-                }
+                // get declarations from base indexers
+                tables->base.lookupId( id, out );
         }
 
@@ -506 +498 @@
         }
 
-        bool Indexer::hasIncompatibleCDecl( const std::string &id, const std::string &mangleName ) const {
+        bool Indexer::hasCDeclWithName( const std::string &id ) const {
                 if ( ! tables ) return false;
 
@@ -513 +505 @@
                         const MangleTable &mangleTable = decls->second;
                         for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
-                                // check for C decls with the same name, skipping 
-                                // those with a compatible type (by mangleName)
-                                if ( decl->second->get_linkage() == LinkageSpec::C && decl->first != mangleName ) return true;
-                        }
-                }
-
-                return tables->base.hasIncompatibleCDecl( id, mangleName );
+                                if ( decl->second->get_linkage() == LinkageSpec::C ) return true;
+                        }
+                }
+
+                return tables->base.hasCDeclWithName( id );
         }
         
@@ -602 +592 @@
                 const std::string &name = decl->get_name();
                 std::string mangleName;
-                if ( LinkageSpec::isOverridable( decl->get_linkage() ) ) {
+                if ( decl->get_linkage() == LinkageSpec::C ) {
+                        mangleName = name;
+                } else if ( LinkageSpec::isOverridable( decl->get_linkage() ) ) {
                         // mangle the name without including the appropriate suffix, so overridable routines are placed into the
                         // same "bucket" as their user defined versions.
@@ -613 +605 @@
                 if ( ! existing || ! addedIdConflicts( existing, decl ) ) {
                         // this ensures that no two declarations with the same unmangled name both have C linkage
-                        if ( decl->get_linkage() == LinkageSpec::C && hasIncompatibleCDecl( name, mangleName ) ) {
+                        if ( decl->get_linkage() == LinkageSpec::C && hasCDeclWithName( name ) ) {
                                 throw SemanticError( "invalid overload of C function ", decl );
-                        } // NOTE this is broken in Richard's original code in such a way that it never triggers (it 
-                          // doesn't check decls that have the same manglename, and all C-linkage decls are defined to 
-                          // have their name as their manglename, hence the error can never trigger).
-                          // The code here is closer to correct, but name mangling would have to be completely 
-                          // isomorphic to C type-compatibility, which it may not be.
+                        }
                         
                         tables->idTable[ name ][ mangleName ] = decl;