Changeset b3ed43a3

Timestamp:

Nov 25, 2020, 12:25:06 PM (3 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

6f1e695

Parents:

04994aa (diff), 5e82d56 (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 plg.uwaterloo.ca:software/cfa/cfa-cc

Files:

• benchmark/plot.py (added)
• libcfa/src/bits/collection.hfa (added)
• libcfa/src/bits/queue.hfa (added)
• libcfa/src/bits/queue_example.cfa (added)
• libcfa/src/bits/sequence.hfa (added)
• libcfa/src/bits/sequence_example.cfa (added)
• libcfa/src/bits/stack.hfa (added)
• libcfa/src/bits/stack_example.cfa (added)
• libcfa/src/concurrency/kernel.cfa (modified) (1 diff)
• src/AST/Expr.hpp (modified) (1 diff)
• src/AST/SymbolTable.cpp (modified) (9 diffs)
• src/AST/SymbolTable.hpp (modified) (4 diffs)
• src/AST/Type.cpp (modified) (1 diff)
• src/AST/Type.hpp (modified) (1 diff)
• src/InitTweak/FixInit.h (modified) (1 diff)
• src/Parser/ParseNode.h (modified) (1 diff)
• src/ResolvExpr/CandidateFinder.cpp (modified) (7 diffs)
• src/ResolvExpr/CandidateFinder.hpp (modified) (1 diff)
• src/ResolvExpr/Resolver.h (modified) (2 diffs)
• src/ResolvExpr/SatisfyAssertions.cpp (modified) (1 diff)
• tests/.expect/KRfunctions.nast.x64.txt (added)
• tests/.expect/KRfunctions.oast.x64.txt (moved) (moved from tests/.expect/KRfunctions.x64.txt)
• tests/.expect/alloc-ERROR.nast.txt (added)
• tests/.expect/alloc-ERROR.oast.txt (moved) (moved from tests/.expect/alloc-ERROR.txt)
• tests/.expect/attributes.nast.x64.txt (added)
• tests/.expect/attributes.oast.x64.txt (moved) (moved from tests/.expect/attributes.x64.txt)
• tests/.expect/functions.nast.x64.txt (added)
• tests/.expect/functions.oast.x64.txt (moved) (moved from tests/.expect/functions.x64.txt)
• tests/.expect/init1-ERROR.nast.txt (added)
• tests/.expect/init1-ERROR.oast.txt (moved) (moved from tests/.expect/init1-ERROR.txt)
• tests/errors/.expect/completeType.nast.x64.txt (added)
• tests/errors/.expect/completeType.oast.x64.txt (moved) (moved from tests/errors/.expect/completeType.x64.txt)
• tests/raii/.expect/ctor-autogen-ERR1.nast.txt (added)
• tests/raii/.expect/ctor-autogen-ERR1.oast.txt (moved) (moved from tests/raii/.expect/ctor-autogen-ERR1.txt)
• tests/raii/.expect/memberCtors-ERR1.nast.txt (added)
• tests/raii/.expect/memberCtors-ERR1.oast.txt (moved) (moved from tests/raii/.expect/memberCtors-ERR1.txt)
• tests/warnings/.expect/self-assignment.nast.txt (added)
• tests/warnings/.expect/self-assignment.oast.txt (moved) (moved from tests/warnings/.expect/self-assignment.txt)

libcfa/src/concurrency/kernel.cfa

@@ -379 +379 @@
 
         ready_schedule_lock();
-                push( thrd->curr_cluster, thrd );
-                __wake_one(thrd->curr_cluster);
+                // Dereference the thread now because once we push it, there is not guaranteed it's still valid.
+                struct cluster * cl = thrd->curr_cluster;
+
+                // push the thread to the cluster ready-queue
+                push( cl, thrd );
+
+                // variable thrd is no longer safe to use
+
+                // wake the cluster using the save variable.
+                __wake_one( cl );
         ready_schedule_unlock();
 

src/AST/Expr.hpp

@@ -299 +299 @@
 };
 
-/// Whether a cast existed in the program source or not
+/// Inidicates whether the cast is introduced by the CFA type system.
+/// GeneratedCast for casts that the resolver introduces to force a return type
+/// ExplicitCast for casts from user code
+/// ExplicitCast for casts from desugaring advanced CFA features into simpler CFA
+/// example
+///   int * p;     // declaration
+///   (float *) p; // use, with subject cast
+/// subject cast being GeneratedCast means we are considering an interpretation with a type mismatch
+/// subject cast being ExplicitCast means someone in charge wants it that way
 enum GeneratedFlag { ExplicitCast, GeneratedCast };
 

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 {};
@@ -107 +121 @@
                 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;
 }
@@ -366 +443 @@
 namespace {
         /// gets the base type of the first parameter; decl must be a ctor/dtor/assignment function
-        std::string getOtypeKey( const FunctionDecl * function ) {
-                const auto & params = function->type->params;
+        std::string getOtypeKey( const FunctionType * ftype, bool stripParams = true ) {
+                const auto & params = ftype->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() );
                 assert( base );
-                return Mangle::mangle( 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 );  
         }
 
@@ -380 +462 @@
                         const DeclWithType * decl, const std::string & otypeKey ) {
                 auto func = dynamic_cast< const FunctionDecl * >( decl );
-                if ( ! func || otypeKey != getOtypeKey( func ) ) return nullptr;
+                if ( ! func || otypeKey != getOtypeKey( func->type, false ) ) return nullptr;
                 return func;
         }
@@ -405 +487 @@
         bool dataIsUserDefinedFunc = ! function->linkage.is_overrideable;
         bool dataIsCopyFunc = InitTweak::isCopyFunction( function );
-        std::string dataOtypeKey = getOtypeKey( function );
+        std::string dataOtypeKey = getOtypeKey( function->type, false ); // requires exact match to override autogen
 
         if ( dataIsUserDefinedFunc && dataIsCopyFunc ) {
@@ -577 +659 @@
                 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;
@@ -607 +711 @@
         // ensure tables exist and add identifier
         MangleTable::Ptr mangleTable;
-        if ( ! idTable ) {
-                idTable = IdTable::new_ptr();
+        if ( ! table ) {
+                table = IdTable::new_ptr();
                 mangleTable = MangleTable::new_ptr();
         } else {
                 ++*stats().map_lookups;
-                auto decls = idTable->find( name );
-                if ( decls == idTable->end() ) {
+                auto decls = table->find( lookupKey );
+                if ( decls == table->end() ) {
                         mangleTable = MangleTable::new_ptr();
                 } else {
@@ -628 +732 @@
                                                 lazyInitScope();
                                                 *stats().map_mutations += 2;
-                                                idTable = idTable->set(
-                                                        name,
+                                                table = table->set(
+                                                        lookupKey,
                                                         mangleTable->set(
                                                                 mangleName,
@@ -644 +748 @@
         IdData data{ decl, baseExpr, deleter, scope };
         // Ensure that auto-generated ctor/dtor/assignment are deleted if necessary
-        if ( ! removeSpecialOverrides( data, mangleTable ) ) return;
+        if (table != idTable) { // adding to special table
+                if ( ! removeSpecialOverrides( data, mangleTable ) ) return;
+        }
         *stats().map_mutations += 2;
-        idTable = idTable->set( name, mangleTable->set( mangleName, std::move(data) ) );
+        table = table->set( lookupKey, mangleTable->set( mangleName, std::move(data) ) );
 }
 

src/AST/SymbolTable.hpp

@@ -33 +33 @@
 class SymbolTable final : public std::enable_shared_from_this<ast::SymbolTable> {
 public:
+        /// special functions stored in dedicated tables, with different lookup keys
+        enum SpecialFunctionKind {CTOR, DTOR, ASSIGN, NUMBER_OF_KINDS};
+        static SpecialFunctionKind getSpecialFunctionKind(const std::string & name);
+
         /// Stored information about a declaration
         struct IdData {
@@ -77 +81 @@
         UnionTable::Ptr unionTable;    ///< union namespace
         TraitTable::Ptr traitTable;    ///< trait namespace
+        IdTable::Ptr specialFunctionTable[NUMBER_OF_KINDS];
+
+        // using SpecialFuncTable = PersistentMap< std::string, IdTable::Ptr >; // fname (ctor/dtor/assign) - otypekey
+        // SpecialFuncTable::Ptr specialFuncTable;
 
         using Ptr = std::shared_ptr<const SymbolTable>;
@@ -95 +103 @@
         /// Gets all declarations with the given ID
         std::vector<IdData> lookupId( const std::string &id ) const;
+        /// Gets special functions associated with a type; if no key is given, returns everything
+        std::vector<IdData> specialLookupId( SpecialFunctionKind kind, const std::string & otypeKey = "" ) const;
         /// Gets the top-most type declaration with the given ID
         const NamedTypeDecl * lookupType( const std::string &id ) const;
@@ -186 +196 @@
                 const Decl * deleter = nullptr );
 
+        /// common code for addId when special decls are placed into separate tables
+        void addId(
+                const DeclWithType * decl, const std::string & lookupKey, IdTable::Ptr & idTable, OnConflict handleConflicts, 
+                const Expr * baseExpr = nullptr, const Decl * deleter = nullptr);
+        
         /// adds all of the members of the Aggregate (addWith helper)
         void addMembers( const AggregateDecl * aggr, const Expr * expr, OnConflict handleConflicts );

src/AST/Type.cpp

@@ -216 +216 @@
 }
 
+bool isUnboundType(const Type * type) {
+        if (auto typeInst = dynamic_cast<const TypeInstType *>(type)) {
+                // xxx - look for a type name produced by renameTyVars.
+
+                // TODO: once TypeInstType representation is updated, it should properly check
+                // if the context id is filled. this is a temporary hack for now
+                if (std::count(typeInst->name.begin(), typeInst->name.end(), '_') >= 3) {
+                        return true;
+                }
+        }
+        return false;
+}
+
 }
 

src/AST/Type.hpp

@@ -535 +535 @@
 };
 
+bool isUnboundType(const Type * type);
+
 }
 

src/InitTweak/FixInit.h

@@ -21 +21 @@
 class Declaration;
 namespace ast {
-        class TranslationUnit;
+        struct TranslationUnit;
 }
 

src/Parser/ParseNode.h

@@ -37 +37 @@
 class Attribute;
 class Declaration;
-class DeclarationNode;
+struct DeclarationNode;
 class DeclarationWithType;
 class ExpressionNode;
 class Initializer;
-class StatementNode;
+struct StatementNode;
 
 //##############################################################################

src/ResolvExpr/CandidateFinder.cpp

@@ -43 +43 @@
 #include "SymTab/Validate.h"      // for validateType
 #include "Tuples/Tuples.h"        // for handleTupleAssignment
+#include "InitTweak/InitTweak.h"  // for getPointerBase
+
+#include "Common/Stats/Counter.h"
 
 #define PRINT( text ) if ( resolvep ) { text }
@@ -864 +867 @@
 
                 void postvisit( const ast::UntypedExpr * untypedExpr ) {
-                        CandidateFinder funcFinder{ symtab, tenv };
-                        funcFinder.find( untypedExpr->func, ResolvMode::withAdjustment() );
-                        // short-circuit if no candidates
-                        if ( funcFinder.candidates.empty() ) return;
-
-                        reason.code = NoMatch;
-
                         std::vector< CandidateFinder > argCandidates =
                                 selfFinder.findSubExprs( untypedExpr->args );
@@ -877 +873 @@
                         // if not tuple assignment, handled as normal function call
                         Tuples::handleTupleAssignment( selfFinder, untypedExpr, argCandidates );
+
+                        CandidateFinder funcFinder{ symtab, tenv };
+                        if (auto nameExpr = untypedExpr->func.as<ast::NameExpr>()) {
+                                auto kind = ast::SymbolTable::getSpecialFunctionKind(nameExpr->name);
+                                if (kind != ast::SymbolTable::SpecialFunctionKind::NUMBER_OF_KINDS) {
+                                        assertf(!argCandidates.empty(), "special function call without argument");
+                                        for (auto & firstArgCand: argCandidates[0]) {
+                                                ast::ptr<ast::Type> argType = firstArgCand->expr->result;
+                                                firstArgCand->env.apply(argType);
+                                                // strip references
+                                                // xxx - is this correct?
+                                                while (argType.as<ast::ReferenceType>()) argType = argType.as<ast::ReferenceType>()->base;
+
+                                                // convert 1-tuple to plain type
+                                                if (auto tuple = argType.as<ast::TupleType>()) {
+                                                        if (tuple->size() == 1) {
+                                                                argType = tuple->types[0];
+                                                        }
+                                                }
+                                                
+                                                // if argType is an unbound type parameter, all special functions need to be searched.
+                                                if (isUnboundType(argType)) {
+                                                        funcFinder.otypeKeys.clear();
+                                                        break;
+                                                }
+
+                                                if (argType.as<ast::PointerType>()) funcFinder.otypeKeys.insert(Mangle::Encoding::pointer);
+                                                else funcFinder.otypeKeys.insert(Mangle::mangle(argType, Mangle::NoGenericParams | Mangle::Type));
+                                        }
+                                }
+                        }
+                        // if candidates are already produced, do not fail
+                        // xxx - is it possible that handleTupleAssignment and main finder both produce candidates?
+                        // this means there exists ctor/assign functions with a tuple as first parameter.
+                        funcFinder.find( untypedExpr->func, selfFinder.candidates.empty() ? ResolvMode::withAdjustment() : ResolvMode::withoutFailFast() );
+                        // short-circuit if no candidates
+                        // if ( funcFinder.candidates.empty() ) return;
+
+                        reason.code = NoMatch;
 
                         // find function operators
@@ -1066 +1101 @@
                                 // unification run for side-effects
                                 unify( toType, cand->expr->result, cand->env, need, have, open, symtab );
-                                Cost thisCost = castCost( cand->expr->result, toType, cand->expr->get_lvalue(),
-                                                symtab, cand->env );
+                                Cost thisCost = 
+                                        (castExpr->isGenerated == ast::GeneratedFlag::GeneratedCast)
+                            ? conversionCost( cand->expr->result, toType, cand->expr->get_lvalue(), symtab, cand->env )
+                            : castCost( cand->expr->result, toType, cand->expr->get_lvalue(), symtab, cand->env );
+
                                 PRINT(
                                         std::cerr << "working on cast with result: " << toType << std::endl;
@@ -1187 +1225 @@
 
                 void postvisit( const ast::NameExpr * nameExpr ) {
-                        std::vector< ast::SymbolTable::IdData > declList = symtab.lookupId( nameExpr->name );
+                        std::vector< ast::SymbolTable::IdData > declList;
+                        if (!selfFinder.otypeKeys.empty()) {
+                                auto kind = ast::SymbolTable::getSpecialFunctionKind(nameExpr->name);
+                                assertf(kind != ast::SymbolTable::SpecialFunctionKind::NUMBER_OF_KINDS, "special lookup with non-special target: %s", nameExpr->name.c_str());
+
+                                for (auto & otypeKey: selfFinder.otypeKeys) {
+                                        auto result = symtab.specialLookupId(kind, otypeKey);
+                                        declList.insert(declList.end(), std::make_move_iterator(result.begin()), std::make_move_iterator(result.end()));
+                                }
+                        }
+                        else {
+                                declList = symtab.lookupId( nameExpr->name );
+                        }
                         PRINT( std::cerr << "nameExpr is " << nameExpr->name << std::endl; )
+
                         if( declList.empty() ) return;
 
@@ -1543 +1594 @@
 
                                         // unification run for side-effects
-                                        unify( toType, cand->expr->result, env, need, have, open, symtab );
+                                        bool canUnify = unify( toType, cand->expr->result, env, need, have, open, symtab );
+                                        (void) canUnify;
                                         Cost thisCost = computeConversionCost( cand->expr->result, toType, cand->expr->get_lvalue(),
+                                                symtab, env );
+                                        PRINT(
+                                                Cost legacyCost = castCost( cand->expr->result, toType, cand->expr->get_lvalue(),
                                                         symtab, env );
-
+                                                std::cerr << "Considering initialization:";
+                                                std::cerr << std::endl << "  FROM: " << cand->expr->result << std::endl;
+                                                std::cerr << std::endl << "  TO: "   << toType             << std::endl;
+                                                std::cerr << std::endl << "  Unification " << (canUnify ? "succeeded" : "failed");
+                                                std::cerr << std::endl << "  Legacy cost " << legacyCost;
+                                                std::cerr << std::endl << "  New cost " << thisCost;
+                                                std::cerr << std::endl;
+                                        )
                                         if ( thisCost != Cost::infinity ) {
                                                 // count one safe conversion for each value that is thrown away
@@ -1558 +1620 @@
                                         }
                                 }
+
                         }
 

src/ResolvExpr/CandidateFinder.hpp

@@ -31 +31 @@
         const ast::TypeEnvironment & env;  ///< Substitutions performed in this resolution
         ast::ptr< ast::Type > targetType;  ///< Target type for resolution
+        std::set< std::string > otypeKeys;  /// different type may map to same key
 
         CandidateFinder(

src/ResolvExpr/Resolver.h

@@ -35 +35 @@
         class StmtExpr;
         class SymbolTable;
-        class TranslationUnit;
+        struct TranslationUnit;
         class Type;
         class TypeEnvironment;
@@ -63 +63 @@
         ast::ptr< ast::Expr > resolveInVoidContext(
                 const ast::Expr * expr, const ast::SymbolTable & symtab, ast::TypeEnvironment & env );
-        /// Resolve `untyped` to the single expression whose candidate is the best match for the 
+        /// Resolve `untyped` to the single expression whose candidate is the best match for the
         /// given type.
         ast::ptr< ast::Expr > findSingleExpression(

src/ResolvExpr/SatisfyAssertions.cpp

@@ -167 +167 @@
                 // find candidates that unify with the desired type
                 AssnCandidateList matches;
-                for ( const ast::SymbolTable::IdData & cdata : sat.symtab.lookupId( assn.first->name ) ) {
+
+                std::vector<ast::SymbolTable::IdData> candidates;
+                auto kind = ast::SymbolTable::getSpecialFunctionKind(assn.first->name);
+                if (kind != ast::SymbolTable::SpecialFunctionKind::NUMBER_OF_KINDS) {
+                        // prefilter special decls by argument type, if already known
+                        ast::ptr<ast::Type> thisArgType = strict_dynamic_cast<const ast::PointerType *>(assn.first->get_type())->base
+                                .strict_as<ast::FunctionType>()->params[0]
+                                .strict_as<ast::ReferenceType>()->base;
+                        sat.cand->env.apply(thisArgType);
+
+                        std::string otypeKey = "";
+                        if (thisArgType.as<ast::PointerType>()) otypeKey = Mangle::Encoding::pointer;
+                        else if (!isUnboundType(thisArgType)) otypeKey = Mangle::mangle(thisArgType, Mangle::Type | Mangle::NoGenericParams);
+
+                        candidates = sat.symtab.specialLookupId(kind, otypeKey);
+                }
+                else {
+                        candidates = sat.symtab.lookupId(assn.first->name);
+                }
+                for ( const ast::SymbolTable::IdData & cdata : candidates ) {
                         const ast::DeclWithType * candidate = cdata.id;