Changes in src/ResolvExpr/CandidateFinder.cpp [2f31773:06ecda9]

File:

• src/ResolvExpr/CandidateFinder.cpp (modified) (5 diffs)

src/ResolvExpr/CandidateFinder.cpp

@@ -1241 +1241 @@
                 Cost minCastCost = Cost::infinity;
                 for ( CandidateRef & cand : finder.candidates ) {
-                        ast::ptr< ast::Type > fromType = cand->expr->result;
-                        assert( fromType );
-                        fromType = resolveTypeof( fromType, context );
-                        fromType = adjustExprType( fromType, tenv, symtab );
-
                         ast::AssertionSet need( cand->need.begin(), cand->need.end() ), have;
                         ast::OpenVarSet open( cand->open );
@@ -1255 +1250 @@
                         // subexpression results that are cast directly. The candidate is invalid if it
                         // has fewer results than there are types to cast to.
-                        int discardedValues = fromType->size() - toType->size();
+                        int discardedValues = cand->expr->result->size() - toType->size();
                         if ( discardedValues < 0 ) continue;
 
                         // unification run for side-effects
-                        unify( toType, fromType, cand->env, need, have, open );
+                        unify( toType, cand->expr->result, cand->env, need, have, open );
                         Cost thisCost =
                                 (castExpr->isGenerated == ast::GeneratedFlag::GeneratedCast)
-                                        ? conversionCost( fromType, toType, cand->expr->get_lvalue(), symtab, cand->env )
-                                        : castCost( fromType, toType, cand->expr->get_lvalue(), symtab, cand->env );
+                                        ? conversionCost( cand->expr->result, toType, cand->expr->get_lvalue(), symtab, cand->env )
+                                        : castCost( cand->expr->result, toType, cand->expr->get_lvalue(), symtab, cand->env );
                         
                         // Redefine enum cast
-                        auto argAsEnum = fromType.as<ast::EnumInstType>();
+                        auto argAsEnum = cand->expr->result.as<ast::EnumInstType>();
                         auto toAsEnum = toType.as<ast::EnumInstType>();
                         if ( argAsEnum && toAsEnum && argAsEnum->name != toAsEnum->name ) {
@@ -1277 +1272 @@
                         PRINT(
                                 std::cerr << "working on cast with result: " << toType << std::endl;
-                                std::cerr << "and expr type: " << fromType << std::endl;
+                                std::cerr << "and expr type: " << cand->expr->result << std::endl;
                                 std::cerr << "env: " << cand->env << std::endl;
                         )
@@ -1286 +1281 @@
                                 // count one safe conversion for each value that is thrown away
                                 thisCost.incSafe( discardedValues );
-
-                                // See Aaron Moss, page 47; this reasoning does not hold since implicit conversions
-                                // can create the same resolution issue. The C intrinsic interpretations are pruned
-                                // immediately for the lowest cost option regardless of result type. Related code in
-                                // postvisit (UntypedExpr).
-                                // Cast expression costs are updated now to use the general rules.
-                                /*
                                 // select first on argument cost, then conversion cost
                                 if ( cand->cost < minExprCost || ( cand->cost == minExprCost && thisCost < minCastCost ) ) {
@@ -1301 +1289 @@
                                 // ambigious case, still output candidates to print in error message
                                 if ( cand->cost == minExprCost && thisCost == minCastCost ) {
-                                */
-                                cand->cost += thisCost;
-                                if (cand->cost < minExprCost) {
-                                        minExprCost = cand->cost;
-                                        matches.clear();
-                                }
-                                if (cand->cost == minExprCost) {
                                         CandidateRef newCand = std::make_shared<Candidate>(
                                                 restructureCast( cand->expr, toType, castExpr->isGenerated ),
-                                                copy( cand->env ), std::move( open ), std::move( need ), cand->cost);
+                                                copy( cand->env ), std::move( open ), std::move( need ), cand->cost + thisCost);
                                         // currently assertions are always resolved immediately so this should have no effect.
                                         // if this somehow changes in the future (e.g. delayed by indeterminate return type)