Changes in src/ResolvExpr/CandidateFinder.cpp [acb33f15:c92bdcc]

File:

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

src/ResolvExpr/CandidateFinder.cpp

@@ -17 +17 @@
 
 #include <deque>
-#include <iterator>               // for back_inserter
+#include <iterator>                 // for back_inserter
 #include <sstream>
 #include <string>
@@ -25 +25 @@
 #include "AdjustExprType.hpp"
 #include "Candidate.hpp"
-#include "CastCost.hpp"           // for castCost
+#include "CastCost.hpp"             // for castCost
 #include "CompilationState.hpp"
-#include "ConversionCost.h"       // for conversionCast
-#include "Cost.h"
+#include "ConversionCost.hpp"       // for conversionCast
+#include "Cost.hpp"
 #include "ExplodedArg.hpp"
 #include "PolyCost.hpp"
-#include "RenameVars.h"           // for renameTyVars
-#include "Resolver.h"
-#include "ResolveTypeof.h"
+#include "RenameVars.hpp"           // for renameTyVars
+#include "Resolver.hpp"
+#include "ResolveTypeof.hpp"
 #include "SatisfyAssertions.hpp"
 #include "SpecCost.hpp"
-#include "typeops.h"              // for combos
-#include "Unify.h"
-#include "WidenMode.h"
+#include "Typeops.hpp"              // for combos
+#include "Unify.hpp"
+#include "WidenMode.hpp"
 #include "AST/Expr.hpp"
 #include "AST/Node.hpp"
@@ -45 +45 @@
 #include "AST/SymbolTable.hpp"
 #include "AST/Type.hpp"
-#include "Common/utility.h"       // for move, copy
-#include "SymTab/Mangler.h"
-#include "Tuples/Tuples.h"        // for handleTupleAssignment
-#include "InitTweak/InitTweak.h"  // for getPointerBase
-
-#include "Common/Stats/Counter.h"
+#include "Common/Utility.hpp"       // for move, copy
+#include "SymTab/Mangler.hpp"
+#include "Tuples/Tuples.hpp"        // for handleTupleAssignment
+#include "InitTweak/InitTweak.hpp"  // for getPointerBase
+
+#include "Common/Stats/Counter.hpp"
 
 #include "AST/Inspect.hpp"             // for getFunctionName
@@ -906 +906 @@
                                 }
                                 CandidateRef & choice = winners.front();
-                                choice->cost = Cost::unsafe;
+                                choice->cost.incSafe();
                                 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) {
@@ -1021 +1019 @@
                 CandidateList found;
                 SemanticErrorException errors;
-                
                 for ( CandidateRef & func : funcFinder ) {
                         try {
@@ -1096 +1093 @@
                         Cost cvtCost = computeApplicationConversionCost( withFunc, symtab );
 
-                        if (funcName == "?|?") {
                         PRINT(
                                 auto appExpr = withFunc->expr.strict_as< ast::ApplicationExpr >();
@@ -1112 +1108 @@
                                 std::cerr << "cost of conversion is:" << cvtCost << std::endl;
                         )
-                        }
+
                         if ( cvtCost != Cost::infinity ) {
                                 withFunc->cvtCost = cvtCost;
@@ -1778 +1774 @@
                                                 matches.clear();
                                         }
-                                        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 );
+                                        // 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 );
+                                                }
+                                        }
                                 }
                         }