Changeset e5c3811 for src/ResolvExpr

Timestamp:

Nov 25, 2020, 3:12:17 AM (3 years ago)

Author:

Fangren Yu <f37yu@…>

Branches:

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

Children:

4702a2c

Parents:

7192145

Message:

create dedicated symbol tables for big 3 operators
note: arbitrary this param type is not supported; it is currently allowed although never used

Location:

src/ResolvExpr

Files:

• CandidateFinder.cpp (modified) (5 diffs)
• CandidateFinder.hpp (modified) (1 diff)
• SatisfyAssertions.cpp (modified) (1 diff)

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
@@ -1187 +1222 @@
 
                 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;
 
@@ -1558 +1606 @@
                                         }
                                 }
+
                         }
 

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/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;