Changeset b3bd772

Timestamp:

Dec 14, 2018, 5:12:48 PM (5 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer, pthread-emulation, qualifiedEnum

Children:

8deaf2b

Parents:

9aaacc27

Message:

Prune in resolveAssertions conditional on result type of expression

File:

• src/ResolvExpr/ResolveAssertions.cc (modified) (3 diffs)

src/ResolvExpr/ResolveAssertions.cc

@@ -16 +16 @@
 #include "ResolveAssertions.h"
 
+#include <algorithm>                // for sort
 #include <cassert>                  // for assertf
 #include <list>                     // for list
+#include <memory>                   // for unique_ptr
 #include <unordered_map>            // for unordered_map, unordered_multimap
 #include <utility>                  // for move
@@ -27 +29 @@
 #include "ResolvExpr/RenameVars.h"  // for renameTyVars
 #include "SymTab/Indexer.h"         // for Indexer
+#include "SymTab/Mangler.h"         // for Mangler
 #include "SynTree/Expression.h"     // for InferredParams
 #include "TypeEnvironment.h"        // for TypeEnvironment, etc.
@@ -370 +373 @@
                                         }
                                 } else {
-                                        // resolve deferred assertions by mutual compatibility and sort by cost
+                                        // resolve deferred assertions by mutual compatibility
                                         std::vector<CandidateEnvMerger::OutType> compatible = filterCombos(
                                                 resn.deferred, 
                                                 CandidateEnvMerger{ resn.alt.env, resn.alt.openVars, resn.indexer } );
-                                        auto lmin = sort_mins( compatible.begin(), compatible.end(), 
-                                                CandidateCost{resn.indexer} );
-                                        
-                                        for ( auto it = compatible.begin(); it != lmin ; ++it ) {
-                                                auto& compat = *it;
+                                        // sort by cost
+                                        CandidateCost coster{ resn.indexer };
+                                        std::sort( compatible.begin(), compatible.end(), coster );
+                                        // // sort by cost if pruning
+                                        // if ( pruneAssertions ) {
+                                        //      auto lmin = sort_mins( compatible.begin(), compatible.end(), 
+                                        //              CandidateCost{resn.indexer} );
+                                        //      compatible.erase( lmin, compatible.end() );
+                                        // }
+
+                                        // keep map of detected options
+                                        std::unordered_map<std::string, Cost> found;
+                                        for ( auto& compat : compatible ) {
+                                                // filter by environment-adjusted result type, keep only cheapest option
+                                                Type* resType = alt.expr->result->clone();
+                                                compat.env.apply( resType );
+                                                // skip if cheaper alternative already processed with same result type
+                                                Cost resCost = coster.get( compat );
+                                                auto it = found.emplace( SymTab::Mangler::mangleType( resType ), resCost );
+                                                if ( it.second == false && it.first->second < resCost ) continue;
+
+                                                // proceed with resolution step
                                                 ResnState new_resn = resn;