Changes in src/AST/SymbolTable.cpp [3e5dd913:e67991f]

File:

• src/AST/SymbolTable.cpp (modified) (12 diffs)

src/AST/SymbolTable.cpp

@@ -95 +95 @@
 }
 
-SymbolTable::SpecialFunctionKind SymbolTable::getSpecialFunctionKind(const std::string & name) {
-        if (name == "?{}") return CTOR;
-        if (name == "^?{}") return DTOR;
-        if (name == "?=?") return ASSIGN;
-        return NUMBER_OF_KINDS;
-}
-
 std::vector<SymbolTable::IdData> SymbolTable::lookupId( const std::string &id ) const {
-        static Stats::Counters::CounterGroup * name_lookup_stats = Stats::Counters::build<Stats::Counters::CounterGroup>("Name Lookup Stats");
-        static std::map<std::string, Stats::Counters::SimpleCounter *> lookups_by_name;
-        static std::map<std::string, Stats::Counters::SimpleCounter *> candidates_by_name;
-
-        SpecialFunctionKind kind = getSpecialFunctionKind(id);
-        if (kind != NUMBER_OF_KINDS) return specialLookupId(kind);
-
         ++*stats().lookup_calls;
         if ( ! idTable ) return {};
@@ -121 +107 @@
                 out.push_back( decl.second );
         }
-
-        if (Stats::Counters::enabled) {
-                if (! lookups_by_name.count(id)) {
-                        // leaks some strings, but it is because Counters do not hold them
-                        auto lookupCounterName = new std::string(id + "%count");
-                        auto candidatesCounterName = new std::string(id + "%candidate");
-                        lookups_by_name.emplace(id, new Stats::Counters::SimpleCounter(lookupCounterName->c_str(), name_lookup_stats));
-                        candidates_by_name.emplace(id, new Stats::Counters::SimpleCounter(candidatesCounterName->c_str(), name_lookup_stats));
-                }
-                (*lookups_by_name[id]) ++;
-                *candidates_by_name[id] += out.size();
-        }
-
-        return out;
-}
-
-std::vector<SymbolTable::IdData> SymbolTable::specialLookupId( SymbolTable::SpecialFunctionKind kind, const std::string & otypeKey ) const {
-        static Stats::Counters::CounterGroup * special_stats = Stats::Counters::build<Stats::Counters::CounterGroup>("Special Lookups");
-        static Stats::Counters::SimpleCounter * stat_counts[3] = {
-                Stats::Counters::build<Stats::Counters::SimpleCounter>("constructor - count", special_stats),
-                Stats::Counters::build<Stats::Counters::SimpleCounter>("destructor - count", special_stats),
-                Stats::Counters::build<Stats::Counters::SimpleCounter>("assignment - count", special_stats)
-        };
-
-        static Stats::Counters::SimpleCounter * stat_candidates[3] = {
-                Stats::Counters::build<Stats::Counters::SimpleCounter>("constructor - candidates", special_stats),
-                Stats::Counters::build<Stats::Counters::SimpleCounter>("destructor - candidates", special_stats),
-                Stats::Counters::build<Stats::Counters::SimpleCounter>("assignment - candidates", special_stats)
-        };
-
-        static Stats::Counters::SimpleCounter * num_lookup_with_key 
-                = Stats::Counters::build<Stats::Counters::SimpleCounter>("keyed lookups", special_stats);
-        static Stats::Counters::SimpleCounter * num_lookup_without_key 
-                = Stats::Counters::build<Stats::Counters::SimpleCounter>("unkeyed lookups", special_stats);
-
-        assert (kind != NUMBER_OF_KINDS);
-        ++*stats().lookup_calls;
-        if ( ! specialFunctionTable[kind] ) return {};
-
-        std::vector<IdData> out;
-
-        if (otypeKey.empty()) { // returns everything
-                ++*num_lookup_without_key;
-                for (auto & table : *specialFunctionTable[kind]) {
-                        for (auto & decl : *table.second) {
-                                out.push_back(decl.second);
-                        }
-                }
-        }
-        else {
-                ++*num_lookup_with_key;
-                ++*stats().map_lookups;
-                auto decls = specialFunctionTable[kind]->find(otypeKey);
-                if (decls == specialFunctionTable[kind]->end()) return {};
-
-                for (auto decl : *(decls->second)) {
-                        out.push_back(decl.second);
-                }
-        }
-
-        ++*stat_counts[kind];
-        *stat_candidates[kind] += out.size();
-
         return out;
 }
@@ -390 +313 @@
                 if ( ! expr->result ) continue;
                 const Type * resTy = expr->result->stripReferences();
-                auto aggrType = dynamic_cast< const BaseInstType * >( resTy );
+                auto aggrType = dynamic_cast< const ReferenceToType * >( resTy );
                 assertf( aggrType, "WithStmt expr has non-aggregate type: %s",
                         toString( expr->result ).c_str() );
@@ -412 +335 @@
 }
 
-
-void SymbolTable::addFunction( const FunctionDecl * func ) {
-        for (auto & td : func->type_params) {
-                addType(td);
-        }
-        for (auto & asst : func->assertions) {
-                addId(asst);
-        }
-        // addTypes( func->type->forall );
-        addIds( func->returns );
-        addIds( func->params );
-}
-
+void SymbolTable::addFunctionType( const FunctionType * ftype ) {
+        addTypes( ftype->forall );
+        addIds( ftype->returns );
+        addIds( ftype->params );
+}
 
 void SymbolTable::lazyInitScope() {
@@ -449 +364 @@
 namespace {
         /// gets the base type of the first parameter; decl must be a ctor/dtor/assignment function
-        std::string getOtypeKey( const FunctionType * ftype, bool stripParams = true ) {
-                const auto & params = ftype->params;
+        std::string getOtypeKey( const FunctionDecl * function ) {
+                const auto & params = function->type->params;
                 assert( ! params.empty() );
                 // use base type of pointer, so that qualifiers on the pointer type aren't considered.
-                const Type * base = InitTweak::getPointerBase( params.front() );
+                const Type * base = InitTweak::getPointerBase( params.front()->get_type() );
                 assert( base );
-                if (stripParams) {
-                        if (dynamic_cast<const PointerType *>(base)) return Mangle::Encoding::pointer;
-                        return Mangle::mangle( base, Mangle::Type | Mangle::NoGenericParams );
-                }
-                else
-                        return Mangle::mangle( base );  
+                return Mangle::mangle( base );
         }
 
@@ -468 +378 @@
                         const DeclWithType * decl, const std::string & otypeKey ) {
                 auto func = dynamic_cast< const FunctionDecl * >( decl );
-                if ( ! func || otypeKey != getOtypeKey( func->type, false ) ) return nullptr;
+                if ( ! func || otypeKey != getOtypeKey( func ) ) return nullptr;
                 return func;
         }
@@ -493 +403 @@
         bool dataIsUserDefinedFunc = ! function->linkage.is_overrideable;
         bool dataIsCopyFunc = InitTweak::isCopyFunction( function );
-        std::string dataOtypeKey = getOtypeKey( function->type, false ); // requires exact match to override autogen
+        std::string dataOtypeKey = getOtypeKey( function );
 
         if ( dataIsUserDefinedFunc && dataIsCopyFunc ) {
@@ -665 +575 @@
                 const DeclWithType * decl, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr,
                 const Decl * deleter ) {
-        SpecialFunctionKind kind = getSpecialFunctionKind(decl->name);
-        if (kind == NUMBER_OF_KINDS) { // not a special decl
-                addId(decl, decl->name, idTable, handleConflicts, baseExpr, deleter);
-        }
-        else {
-                std::string key;
-                if (auto func = dynamic_cast<const FunctionDecl *>(decl)) {
-                        key = getOtypeKey(func->type);
-                }
-                else if (auto obj = dynamic_cast<const ObjectDecl *>(decl)) {
-                        key = getOtypeKey(obj->type.strict_as<PointerType>()->base.strict_as<FunctionType>());
-                }
-                else {
-                        assertf(false, "special decl with non-function type");
-                }
-                addId(decl, key, specialFunctionTable[kind], handleConflicts, baseExpr, deleter);
-        }
-}
-
-void SymbolTable::addId(
-                const DeclWithType * decl, const std::string & lookupKey, IdTable::Ptr & table, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr,
-                const Decl * deleter ) {
         ++*stats().add_calls;
         const std::string &name = decl->name;
@@ -717 +605 @@
         // ensure tables exist and add identifier
         MangleTable::Ptr mangleTable;
-        if ( ! table ) {
-                table = IdTable::new_ptr();
+        if ( ! idTable ) {
+                idTable = IdTable::new_ptr();
                 mangleTable = MangleTable::new_ptr();
         } else {
                 ++*stats().map_lookups;
-                auto decls = table->find( lookupKey );
-                if ( decls == table->end() ) {
+                auto decls = idTable->find( name );
+                if ( decls == idTable->end() ) {
                         mangleTable = MangleTable::new_ptr();
                 } else {
@@ -738 +626 @@
                                                 lazyInitScope();
                                                 *stats().map_mutations += 2;
-                                                table = table->set(
-                                                        lookupKey,
+                                                idTable = idTable->set(
+                                                        name,
                                                         mangleTable->set(
                                                                 mangleName,
@@ -754 +642 @@
         IdData data{ decl, baseExpr, deleter, scope };
         // Ensure that auto-generated ctor/dtor/assignment are deleted if necessary
-        if (table != idTable) { // adding to special table
-                if ( ! removeSpecialOverrides( data, mangleTable ) ) return;
-        }
+        if ( ! removeSpecialOverrides( data, mangleTable ) ) return;
         *stats().map_mutations += 2;
-        table = table->set( lookupKey, mangleTable->set( mangleName, std::move(data) ) );
+        idTable = idTable->set( name, mangleTable->set( mangleName, std::move(data) ) );
 }
 
@@ -768 +654 @@
                         if ( dwt->name == "" ) {
                                 const Type * t = dwt->get_type()->stripReferences();
-                                if ( auto rty = dynamic_cast<const BaseInstType *>( t ) ) {
+                                if ( auto rty = dynamic_cast<const ReferenceToType *>( t ) ) {
                                         if ( ! dynamic_cast<const StructInstType *>(rty)
                                                 && ! dynamic_cast<const UnionInstType *>(rty) ) continue;