Changeset 2870cb6

Timestamp:

Aug 13, 2024, 6:17:27 PM (12 hours ago)

Author:

Fangren Yu <f37yu@…>

Branches:

master

Parents:

661e7b0

Message:

update cast expression cost rule

File:

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

src/ResolvExpr/CandidateFinder.cpp

@@ -1281 +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 ) ) {
@@ -1289 +1296 @@
                                 // 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 + thisCost);
+                                                copy( cand->env ), std::move( open ), std::move( need ), cand->cost);
                                         // 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)