Changeset acb33f15 for src/ResolvExpr/CandidateFinder.cpp

Timestamp:

May 13, 2024, 10:26:52 AM (5 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

31f4837

Parents:

41c8312

Message:

Change enum conversion steps

File:

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

src/ResolvExpr/CandidateFinder.cpp

@@ -906 +906 @@
                                 }
                                 CandidateRef & choice = winners.front();
-                                choice->cost.incSafe();
+                                choice->cost = Cost::unsafe;
                                 candidates.emplace_back( std::move(choice) );
                         }
@@ -955 +955 @@
 
                 CandidateFinder funcFinder( context, tenv );
+                std::string funcName;
                 if (auto nameExpr = untypedExpr->func.as<ast::NameExpr>()) {
+                        funcName = nameExpr->name;
                         auto kind = ast::SymbolTable::getSpecialFunctionKind(nameExpr->name);
                         if (kind != ast::SymbolTable::SpecialFunctionKind::NUMBER_OF_KINDS) {
@@ -1019 +1021 @@
                 CandidateList found;
                 SemanticErrorException errors;
+                
                 for ( CandidateRef & func : funcFinder ) {
                         try {
@@ -1093 +1096 @@
                         Cost cvtCost = computeApplicationConversionCost( withFunc, symtab );
 
+                        if (funcName == "?|?") {
                         PRINT(
                                 auto appExpr = withFunc->expr.strict_as< ast::ApplicationExpr >();
@@ -1108 +1112 @@
                                 std::cerr << "cost of conversion is:" << cvtCost << std::endl;
                         )
-
+                        }
                         if ( cvtCost != Cost::infinity ) {
                                 withFunc->cvtCost = cvtCost;
@@ -1774 +1778 @@
                                                 matches.clear();
                                         }
-                                        // ambiguous case, still output candidates to print in error message
-                                        if ( cand->cost == minExprCost && thisCost == minCastCost ) {
-                                                auto commonAsEnumAttr = common.as<ast::EnumAttrType>();
-                                                if ( commonAsEnumAttr && commonAsEnumAttr->attr == ast::EnumAttribute::Value ) {
-                                                        auto callExpr = new ast::UntypedExpr(
-                                                                cand->expr->location, new ast::NameExpr( cand->expr->location, "valueE"), {cand->expr} );
-                                                        CandidateFinder finder( context, env );
-                                                        finder.find( callExpr );
-                                                        CandidateList winners = findMinCost( finder.candidates );
-                                                        if (winners.size() != 1) {
-                                                                SemanticError( callExpr, "Ambiguous expression in valueE..." );
-                                                        }
-                                                        CandidateRef & choice = winners.front();
-                                                        // assert( valueCall->result );
-                                                        CandidateRef newCand = std::make_shared<Candidate>(
-                                                                new ast::InitExpr{
-                                                                        initExpr->location,
-                                                                        // restructureCast( cand->expr, toType ),
-                                                                        choice->expr,
-                                                                        initAlt.designation },
-                                                                std::move(env), std::move( open ), std::move( need ), cand->cost + thisCost );
-                                                                inferParameters( newCand, matches );
-                                                } else {
-                                                        CandidateRef newCand = std::make_shared<Candidate>(
-                                                                new ast::InitExpr{
-                                                                        initExpr->location,
-                                                                        restructureCast( cand->expr, toType ),
-                                                                        initAlt.designation },
-                                                                std::move(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)
-                                                        // we may need to revisit the logic.
-                                                        inferParameters( newCand, matches );
-                                                }
-                                        }
+                                        CandidateRef newCand = std::make_shared<Candidate>(
+                                                new ast::InitExpr{
+                                                        initExpr->location,
+                                                        restructureCast( cand->expr, toType ),
+                                                        initAlt.designation },
+                                                std::move(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)
+                                        // we may need to revisit the logic.
+                                        inferParameters( newCand, matches );
                                 }
                         }