Changes in src/ResolvExpr/CandidateFinder.cpp [cdb4eaa:7a780ad]

File:

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

src/ResolvExpr/CandidateFinder.cpp

@@ -513 +513 @@
                                         // add new result
                                         assert( common );
+                                        // auto attrType = common.as<ast::EnumAttrType>();
+                                        // if ( attrType && ( attrType->attr == ast::EnumAttribute::Value ) ) {
+                                        //      auto callExpr = new ast::UntypedExpr(
+                                        //              expr->location, new ast::NameExpr( expr->location, "valueE"), {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();
+                                        //      choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
+
+                                        //      results.emplace_back(
+                                        //              i, choice->expr, 
+                                        //              std::move( env ), std::move( need ), std::move( have ), std::move( open ),
+                                        //              nextArg + 1, nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
+                                        // } else {
                                                 results.emplace_back(
                                                         i, expr, std::move( env ), std::move( need ), std::move( have ), std::move( open ),
@@ -903 +921 @@
                                 CandidateList winners = findMinCost( finder.candidates );
                                 if (winners.size() != 1) {
-                                        SemanticError( callExpr, "Ambiguous expression in valueE..." );
+                                        SemanticError( callExpr, "Ambiguous expression in valueE" );
                                 }
                                 CandidateRef & choice = winners.front();
-                                choice->cost.incVar();
+                                // choice->cost.incSafe();
                                 candidates.emplace_back( std::move(choice) );
                         }
@@ -1382 +1400 @@
                                 }
                         }
-                        
+
                         CandidateRef newCand = std::make_shared<Candidate>(
                                 newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, bentConversion? Cost::safe: Cost::zero,
@@ -1776 +1794 @@
                                                 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} );
@@ -1783 +1800 @@
                                                         CandidateList winners = findMinCost( finder.candidates );
                                                         if (winners.size() != 1) {
-                                                                SemanticError( callExpr, "Ambiguous expression in valueE..." );
+                                                                SemanticError( callExpr, "Ambiguous expression in valueE" );
                                                         }
                                                         CandidateRef & choice = winners.front();
@@ -1805 +1822 @@
                                                         // if this somehow changes in the future (e.g. delayed by indeterminate return type)
                                                         // we may need to revisit the logic.
-                                                        inferParameters( newCand, matches );    
+                                                        inferParameters( newCand, matches );
                                                 }
-                                        }                       
-                                }       
+                                        }
+                                }
                         }
                 }
@@ -2133 +2150 @@
 }
 
-// get the valueE(...) ApplicationExpr that returns the enum value
-const ast::Expr * getValueEnumCall( 
-        const ast::Expr * expr, 
-        const ResolvExpr::ResolveContext & context, const ast::TypeEnvironment & env ) {
-                auto callExpr = new ast::UntypedExpr(
-                        expr->location, new ast::NameExpr( expr->location, "valueE"), {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();
-                return choice->expr;
+const ast::Expr * getValueEnumCall( const ast::Expr * expr,
+                const ResolveContext & context, const ast::TypeEnvironment & env ) {
+        auto callExpr = new ast::UntypedExpr(
+                expr->location, new ast::NameExpr( expr->location, "valueE"), {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();
+        return choice->expr;
 }
 
@@ -2161 +2176 @@
                         }
                 ),
-                new ast::BasicType( ast::BasicType::SignedInt )
+                new ast::BasicType( ast::BasicKind::SignedInt )
         );
 }