Changes in src/ResolvExpr/CandidateFinder.cpp [0522ebe:2beaf9b]

File:

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

src/ResolvExpr/CandidateFinder.cpp

@@ -891 +891 @@
                 } else if ( auto unionInst = aggrExpr->result.as< ast::UnionInstType >() ) {
                         addAggMembers( unionInst, aggrExpr, *cand, Cost::unsafe, "" );
-                } 
-                else if ( auto enumInst = aggrExpr->result.as< ast::EnumInstType >() ) {
-                        if (enumInst->base && enumInst->base->base) {
-            const CodeLocation &location = cand->expr->location;
-
-            CandidateFinder funcFinder(context, tenv);
-            auto nameExpr = new ast::NameExpr(location, "valueE");
-            ResolveMode mode = {true, false, selfFinder.candidates.empty()};
-            funcFinder.find( nameExpr, mode );
-
-            // make variableExpr itself the candidate for the value Call
-            ExplodedArgs argExpansions;
-            argExpansions.emplace_back();
-            auto &argE = argExpansions.back();
-
-            argE.emplace_back(*cand, symtab); // Use the typed name expr as param for value
-
-            CandidateList found;
-            SemanticErrorException errors;
-
-            for (CandidateRef &func : funcFinder) {
-                try {
-                    const ast::Type *funcResult =
-                        func->expr->result->stripReferences();
-                    if (auto pointer = dynamic_cast<const ast::PointerType *>(
-                            funcResult)) {
-                        if (auto function =
-                                pointer->base.as<ast::FunctionType>()) {
-                            CandidateRef newFunc{new Candidate{*func}};
-                            newFunc->expr = referenceToRvalueConversion(
-                                newFunc->expr, newFunc->cost);
-                            makeFunctionCandidates( location,
-                                                   newFunc, function,
-                                                   argExpansions, found );
-                        }
-                    }
-                } catch (SemanticErrorException &e) {
-                    std::cerr
-                        << "Resolving value function should cause an error"
-                        << std::endl;
-                    errors.append(e);
-                }
-            }
-
-            if (found.empty()) {
-                std::cerr << "Resolve value function should always success"
-                          << std::endl;
-            }
-
-            for (CandidateRef &withFunc : found) {
-                withFunc->cost.incSafe();
-                Cost cvtCost =
-                    computeApplicationConversionCost(withFunc, symtab);
-                assert(cvtCost != Cost::infinity);
-
-                candidates.emplace_back(std::move(withFunc));
-            }
-        }
+                } else if ( auto enumInst = aggrExpr->result.as< ast::EnumInstType >() ) {
+                        // The Attribute Arrays are not yet generated, need to proxy them
+                        // as attribute function call
+                        const CodeLocation & location = cand->expr->location;
+                        if ( enumInst->base && enumInst->base->base ) {
+                                auto valueName = new ast::NameExpr(location, "valueE");
+                                auto untypedValueCall = new ast::UntypedExpr(
+                                        location, valueName, { aggrExpr } );
+                                auto result = ResolvExpr::findVoidExpression( untypedValueCall, context );
+                                assert( result.get() );
+                                CandidateRef newCand = std::make_shared<Candidate>(
+                                        *cand, result, Cost::safe );
+                                candidates.emplace_back( std::move( newCand ) );
+                        }
                 }
         }
@@ -1018 +974 @@
                                         }
 
-                                        if (argType.as<ast::PointerType>()) funcFinder.otypeKeys.insert(Mangle::Encoding::pointer);                                             
+                                        if (argType.as<ast::PointerType>()) funcFinder.otypeKeys.insert(Mangle::Encoding::pointer);
                                         else funcFinder.otypeKeys.insert(Mangle::mangle(argType, Mangle::NoGenericParams | Mangle::Type));
                                 }
@@ -1283 +1239 @@
                                                 restructureCast( cand->expr, toType, castExpr->isGenerated ),
                                                 copy( cand->env ), std::move( open ), std::move( need ), cand->cost + thisCost);
-                                        // currently assertions are always resolved immediately so this should have no effect. 
+                                        // 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.
@@ -1444 +1400 @@
         }
 
-    void Finder::postvisit(const ast::VariableExpr *variableExpr) {
-        // not sufficient to just pass `variableExpr` here, type might have changed
-
-        auto cand = new Candidate(variableExpr, tenv);
-        candidates.emplace_back(cand);
-
-        if (auto enumInst = dynamic_cast<const ast::EnumInstType *>(
-                variableExpr->var->get_type())) {
-            if (enumInst->base && enumInst->base->base) {
-                const CodeLocation &location = cand->expr->location;
-
-                CandidateFinder funcFinder(context, tenv);
-                auto nameExpr = new ast::NameExpr(location, "valueE");
-                ResolveMode mode = {true, false, selfFinder.candidates.empty()};
-                funcFinder.find( nameExpr, mode );
-
-                // make variableExpr itself the candidate for the value Call
-                ExplodedArgs argExpansions;
-                argExpansions.emplace_back();
-                auto &argE = argExpansions.back();
-
-                argE.emplace_back(*cand, symtab);
-
-                CandidateList found;
-                SemanticErrorException errors;
-
-                for (CandidateRef &func : funcFinder) {
-                    try {
-                    const ast::Type *funcResult =
-                        func->expr->result->stripReferences();
-                    if (auto pointer = dynamic_cast<const ast::PointerType *>(
-                            funcResult)) {
-                        if (auto function =
-                                pointer->base.as<ast::FunctionType>()) {
-                            CandidateRef newFunc{new Candidate{*func}};
-                            newFunc->expr = referenceToRvalueConversion(
-                                newFunc->expr, newFunc->cost);
-                            makeFunctionCandidates(variableExpr->location,
-                                                   newFunc, function,
-                                                   argExpansions, found);
-                        }
-                    }
-                    } catch (SemanticErrorException &e) {
-                        std::cerr
-                            << "Resolving value function should cause an error"
-                            << std::endl;
-                        errors.append(e);
-                    }
-                }
-
-                if (found.empty()) {
-                    std::cerr << "Resolve value function should always success"
-                            << std::endl;
-                }
-
-                for (CandidateRef &withFunc : found) {
-                    withFunc->cost.incSafe();
-                    Cost cvtCost =
-                        computeApplicationConversionCost(withFunc, symtab);
-                    assert(cvtCost != Cost::infinity);
-
-                    candidates.emplace_back(std::move(withFunc));
-                }
-            }
-        }
-    }
+        void Finder::postvisit( const ast::VariableExpr * variableExpr ) {
+                // not sufficient to just pass `variableExpr` here, type might have changed since
+                addCandidate( variableExpr, tenv );
+        }
 
         void Finder::postvisit( const ast::ConstantExpr * constantExpr ) {
@@ -1618 +1512 @@
         void Finder::postvisit( const ast::ConditionalExpr * conditionalExpr ) {
                 // candidates for condition
+                ast::ptr<ast::Expr> arg1 = notZeroExpr( conditionalExpr->arg1 );
                 CandidateFinder finder1( context, tenv );
-                ast::ptr<ast::Expr> arg1 = notZeroExpr( conditionalExpr->arg1 );
                 finder1.find( arg1, ResolveMode::withAdjustment() );
                 if ( finder1.candidates.empty() ) return;
 
                 // candidates for true result
+                // FIX ME: resolves and runs arg1 twice when arg2 is missing.
+                ast::Expr const * arg2 = conditionalExpr->arg2;
+                arg2 = arg2 ? arg2 : conditionalExpr->arg1.get();
                 CandidateFinder finder2( context, tenv );
                 finder2.allowVoid = true;
-                finder2.find( conditionalExpr->arg2, ResolveMode::withAdjustment() );
+                finder2.find( arg2, ResolveMode::withAdjustment() );
                 if ( finder2.candidates.empty() ) return;
 
@@ -1897 +1794 @@
                                         CandidateRef newCand =
                                                 std::make_shared<Candidate>(
-                                                        newExpr, copy( tenv ), ast::OpenVarSet{}, 
+                                                        newExpr, copy( tenv ), ast::OpenVarSet{},
                                                         ast::AssertionSet{}, Cost::zero, cost
                                                 );
-                                        
+
                                         if (newCand->expr->env) {
                                                 newCand->env.add(*newCand->expr->env);