Changes in src/ResolvExpr/SatisfyAssertions.cpp [34b4268:251ce80]

File:

• src/ResolvExpr/SatisfyAssertions.cpp (modified) (17 diffs)

src/ResolvExpr/SatisfyAssertions.cpp

@@ -16 +16 @@
 #include "SatisfyAssertions.hpp"
 
-#include <iostream>
 #include <algorithm>
 #include <cassert>
@@ -24 +23 @@
 #include <vector>
 
+#include "AdjustExprType.hpp"
 #include "Candidate.hpp"
 #include "CandidateFinder.hpp"
+#include "CommonType.hpp"
 #include "Cost.h"
 #include "RenameVars.h"
+#include "SpecCost.hpp"
 #include "typeops.h"
 #include "Unify.h"
@@ -43 +45 @@
 #include "SymTab/Mangler.h"
 
-
-
 namespace ResolvExpr {
 
@@ -65 +65 @@
                         ast::AssertionSet && h, ast::AssertionSet && n, ast::OpenVarSet && o, ast::UniqueId rs )
                 : cdata( c ), adjType( at ), env( std::move( e ) ), have( std::move( h ) ),
-                  need( std::move( n ) ), open( std::move( o ) ), resnSlot( rs ) {
-                        if (!have.empty()) {
-                                std::cerr << c.id->location << ':' << c.id->name << std::endl;
-                        }
-                  }
+                  need( std::move( n ) ), open( std::move( o ) ), resnSlot( rs ) {}
         };
 
@@ -143 +139 @@
         };
 
-        enum AssertionResult {Fail, Skip, Success} ;
+        /// Adds a captured assertion to the symbol table
+        void addToSymbolTable( const ast::AssertionSet & have, ast::SymbolTable & symtab ) {
+                for ( auto & i : have ) {
+                        if ( i.second.isUsed ) { symtab.addId( i.first->var ); }
+                }
+        }
 
         /// Binds a single assertion, updating satisfaction state
@@ -154 +155 @@
                         "Assertion candidate does not have a unique ID: %s", toString( candidate ).c_str() );
 
-                ast::Expr * varExpr = match.cdata.combine( cand->expr->location, cand->cost );
+                ast::Expr * varExpr = match.cdata.combine( cand->expr->location, cand->cvtCost );
                 varExpr->result = match.adjType;
                 if ( match.resnSlot ) { varExpr->inferred.resnSlots().emplace_back( match.resnSlot ); }
@@ -164 +165 @@
 
         /// Satisfy a single assertion
-        AssertionResult satisfyAssertion( ast::AssertionList::value_type & assn, SatState & sat, bool skipUnbound = false) {
+        bool satisfyAssertion( ast::AssertionList::value_type & assn, SatState & sat, bool allowConversion = false, bool skipUnbound = false) {
                 // skip unused assertions
-                static unsigned int cnt = 0;
-                if ( ! assn.second.isUsed ) return AssertionResult::Success;
-
-                if (assn.first->var->name[1] == '|') std::cerr << ++cnt << std::endl;
+                if ( ! assn.second.isUsed ) return true;
 
                 // find candidates that unify with the desired type
-                AssnCandidateList matches, inexactMatches;
+                AssnCandidateList matches;
 
                 std::vector<ast::SymbolTable::IdData> candidates;
@@ -186 +184 @@
                         if (thisArgType.as<ast::PointerType>()) otypeKey = Mangle::Encoding::pointer;
                         else if (!isUnboundType(thisArgType)) otypeKey = Mangle::mangle(thisArgType, Mangle::Type | Mangle::NoGenericParams);
-                        else if (skipUnbound) return AssertionResult::Skip;
+                        else if (skipUnbound) return false;
 
                         candidates = sat.symtab.specialLookupId(kind, otypeKey);
@@ -214 +212 @@
 
                         ast::OpenVarSet closed;
-                        // findOpenVars( toType, newOpen, closed, newNeed, have, FirstClosed );
-                        findOpenVars( adjType, newOpen, closed, newNeed, have, newEnv, FirstOpen );
-                        ast::TypeEnvironment tempNewEnv {newEnv};
-
-                        if ( unifyExact( toType, adjType, tempNewEnv, newNeed, have, newOpen, WidenMode {true, true}, sat.symtab ) ) {
-                                // set up binding slot for recursive assertions
-                                ast::UniqueId crntResnSlot = 0;
-                                if ( ! newNeed.empty() ) {
-                                        crntResnSlot = ++globalResnSlot;
-                                        for ( auto & a : newNeed ) { a.second.resnSlot = crntResnSlot; }
-                                }
-
-                                matches.emplace_back(
-                                        cdata, adjType, std::move( tempNewEnv ), std::move( have ), std::move( newNeed ),
-                                        std::move( newOpen ), crntResnSlot );
-                        }
-                        else if ( matches.empty() ) {
-                                // restore invalidated env
-                                // newEnv = sat.cand->env;
-                                // newNeed.clear();
-                                if ( auto c = commonType( toType, adjType, newEnv, newNeed, have, newOpen, WidenMode {true, true}, sat.symtab ) ) {
+                        findOpenVars( toType, newOpen, closed, newNeed, have, FirstClosed );
+                        findOpenVars( adjType, newOpen, closed, newNeed, have, FirstOpen );
+                        if ( allowConversion ) {
+                                if ( auto c = commonType( toType, adjType, newEnv, newNeed, have, newOpen, WidenMode {true, true} ) ) {
                                         // set up binding slot for recursive assertions
                                         ast::UniqueId crntResnSlot = 0;
@@ -242 +223 @@
                                         }
 
-                                        inexactMatches.emplace_back(
+                                        matches.emplace_back(
                                                 cdata, adjType, std::move( newEnv ), std::move( have ), std::move( newNeed ),
                                                 std::move( newOpen ), crntResnSlot );
                                 }
                         }
+                        else {
+                                if ( unifyExact( toType, adjType, newEnv, newNeed, have, newOpen, WidenMode {true, true} ) ) {
+                                        // set up binding slot for recursive assertions
+                                        ast::UniqueId crntResnSlot = 0;
+                                        if ( ! newNeed.empty() ) {
+                                                crntResnSlot = ++globalResnSlot;
+                                                for ( auto & a : newNeed ) { a.second.resnSlot = crntResnSlot; }
+                                        }
+
+                                        matches.emplace_back(
+                                                cdata, adjType, std::move( newEnv ), std::move( have ), std::move( newNeed ),
+                                                std::move( newOpen ), crntResnSlot );
+                                }
+                        }
                 }
 
                 // break if no satisfying match
-                if ( matches.empty() ) matches = std::move(inexactMatches);
-                if ( matches.empty() ) return AssertionResult::Fail;
+                if ( matches.empty() ) return false;
 
                 // defer if too many satisfying matches
                 if ( matches.size() > 1 ) {
                         sat.deferred.emplace_back( assn.first, assn.second, std::move( matches ) );
-                        return AssertionResult::Success;
+                        return true;
                 }
 
                 // otherwise bind unique match in ongoing scope
                 AssnCandidate & match = matches.front();
-                // addToSymbolTable( match.have, sat.symtab );
+                addToSymbolTable( match.have, sat.symtab );
                 sat.newNeed.insert( match.need.begin(), match.need.end() );
                 sat.cand->env = std::move( match.env );
@@ -267 +261 @@
 
                 bindAssertion( assn.first, assn.second, sat.cand, match, sat.inferred );
-                return AssertionResult::Success;
+                return true;
         }
 
@@ -398 +392 @@
                         mergeOpenVars( open, i.match.open );
 
-                        if ( ! env.combine( i.match.env, open, symtab ) ) return false;
+                        if ( ! env.combine( i.match.env, open ) ) return false;
 
                         crnt.emplace_back( i );
@@ -444 +438 @@
                 // for each current mutually-compatible set of assertions
                 for ( SatState & sat : sats ) {
+                        bool allowConversion = false;
                         // stop this branch if a better option is already found
                         auto it = thresholds.find( pruneKey( *sat.cand ) );
@@ -452 +447 @@
                         for (unsigned resetCount = 0; ; ++resetCount) {
                                 ast::AssertionList next;
+                                resetTyVarRenaming();
                                 // make initial pass at matching assertions
                                 for ( auto & assn : sat.need ) {
-                                        resetTyVarRenaming();
                                         // fail early if any assertion is not satisfiable
-                                        auto result = satisfyAssertion( assn, sat, !next.empty() );
-                                        if ( result == AssertionResult::Fail ) {
+                                        if ( ! satisfyAssertion( assn, sat, allowConversion, !next.empty() ) ) {
+                                                next.emplace_back(assn);
+                                                // goto nextSat;
+                                        }
+                                }
+                                // success
+                                if (next.empty()) break;
+                                // fail if nothing resolves
+                                else if (next.size() == sat.need.size()) {
+                                        if (allowConversion) {
                                                 Indenter tabs{ 3 };
                                                 std::ostringstream ss;
@@ -463 +466 @@
                                                 print( ss, *sat.cand, ++tabs );
                                                 ss << (tabs-1) << "Could not satisfy assertion:\n";
-                                                ast::print( ss, assn.first, tabs );
+                                                ast::print( ss, next[0].first, tabs );
 
                                                 errors.emplace_back( ss.str() );
                                                 goto nextSat;
                                         }
-                                        else if ( result == AssertionResult::Skip ) {
-                                                next.emplace_back(assn);
-                                                // goto nextSat;
-                                        }
-                                }
-                                // success
-                                if (next.empty()) break;
-
+
+                                        else {
+                                                allowConversion = true;
+                                                continue;
+                                        }
+                                }
+                                allowConversion = false;
                                 sat.need = std::move(next);
                         }
@@ -529 +531 @@
                                                 sat.cand->expr, std::move( compat.env ), std::move( compat.open ),
                                                 ast::AssertionSet{} /* need moved into satisfaction state */,
-                                                sat.cand->cost );
+                                                sat.cand->cost, sat.cand->cvtCost );
 
                                         ast::AssertionSet nextNewNeed{ sat.newNeed };
@@ -542 +544 @@
                                         for ( DeferRef r : compat.assns ) {
                                                 AssnCandidate match = r.match;
-                                                // addToSymbolTable( match.have, nextSymtab );
+                                                addToSymbolTable( match.have, nextSymtab );
                                                 nextNewNeed.insert( match.need.begin(), match.need.end() );