Changeset 432ce7a for src/ResolvExpr/CandidateFinder.cpp

Timestamp:

Jun 11, 2019, 5:52:50 PM (5 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

6625727

Parents:

4b7cce6

Message:

Port CandidateFinder::postvisit for UntypedExpr?, stub dependencies

File:

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

src/ResolvExpr/CandidateFinder.cpp

@@ -16 +16 @@
 #include "CandidateFinder.hpp"
 
+#include <deque>
 #include <iterator>               // for back_inserter
 #include <sstream>
 #include <string>
 #include <unordered_map>
+#include <vector>
 
 #include "Candidate.hpp"
 #include "CompilationState.h"
 #include "Cost.h"
+#include "ExplodedArg.hpp"
 #include "Resolver.h"
 #include "SatisfyAssertions.hpp"
@@ -33 +36 @@
 #include "AST/Print.hpp"
 #include "AST/SymbolTable.hpp"
+#include "AST/Type.hpp"
 #include "SymTab/Mangler.h"
+#include "Tuples/Tuples.h"        // for handleTupleAssignment
 
 #define PRINT( text ) if ( resolvep ) { text }
@@ -40 +45 @@
 
 namespace {
+
+        /// First index is which argument, second is which alternative, third is which exploded element
+        using ExplodedArgs_new = std::deque< std::vector< ExplodedArg > >;
+
+        /// Returns a list of alternatives with the minimum cost in the given list
+        CandidateList findMinCost( const CandidateList & candidates ) {
+                CandidateList out;
+                Cost minCost = Cost::infinity;
+                for ( const CandidateRef & r : candidates ) {
+                        if ( r->cost < minCost ) {
+                                minCost = r->cost;
+                                out.clear();
+                                out.emplace_back( r );
+                        } else if ( r->cost == minCost ) {
+                                out.emplace_back( r );
+                        }
+                }
+                return out;
+        }
+
+        /// Computes conversion cost for a given candidate
+        Cost computeApplicationConversionCost( 
+                const CandidateRef & cand, const ast::SymbolTable & symtab 
+        ) {
+                #warning unimplemented
+                (void)cand; (void)symtab;
+                assert(false);
+                return Cost::infinity;
+        }
 
         /// Actually visits expressions to find their candidate interpretations
@@ -65 +99 @@
                 }
 
+                /// Builds a list of candidates for a function, storing them in out
+                void makeFunctionCandidates(
+                        const CandidateRef & func, const ast::FunctionType * funcType, 
+                        const ExplodedArgs_new & args, CandidateList & out
+                ) {
+                        #warning unimplemented
+                        (void)func; (void)funcType; (void)args; (void)out;
+                        assert(false);
+                }
+
+                /// Adds implicit struct-conversions to the alternative list
+                void addAnonConversions( const CandidateRef & cand ) {
+                        #warning unimplemented
+                        (void)cand;
+                        assert(false);
+                }
+
                 void postvisit( const ast::UntypedExpr * untypedExpr ) {
-                        #warning unimplemented
-                        (void)untypedExpr;
-                        assert(false);
+                        CandidateFinder funcFinder{ symtab, tenv };
+                        funcFinder.find( untypedExpr->func, ResolvMode::withAdjustment() );
+                        // short-circuit if no candidates
+                        if ( funcFinder.candidates.empty() ) return;
+
+                        std::vector< CandidateFinder > argCandidates = 
+                                selfFinder.findSubExprs( untypedExpr->args );
+                        
+                        // take care of possible tuple assignments
+                        // if not tuple assignment, handled as normal function call
+                        Tuples::handleTupleAssignment( selfFinder, untypedExpr, argCandidates );
+
+                        // find function operators
+                        ast::ptr< ast::Expr > opExpr = new ast::NameExpr{ untypedExpr->location, "?()" };
+                        CandidateFinder opFinder{ symtab, tenv };
+                        // okay if there aren't any function operations
+                        opFinder.find( opExpr, ResolvMode::withoutFailFast() );
+                        PRINT(
+                                std::cerr << "known function ops:" << std::endl;
+                                print( std::cerr, opFinder.candidates, 1 );
+                        )
+
+                        // pre-explode arguments
+                        ExplodedArgs_new argExpansions;
+                        for ( const CandidateFinder & args : argCandidates ) {
+                                argExpansions.emplace_back();
+                                auto & argE = argExpansions.back();
+                                for ( const CandidateRef & arg : args ) { argE.emplace_back( *arg, symtab ); }
+                        }
+
+                        // Find function matches
+                        CandidateList found;
+                        SemanticErrorException errors;
+                        for ( CandidateRef & func : funcFinder ) {
+                                try {
+                                        PRINT(
+                                                std::cerr << "working on alternative:" << std::endl;
+                                                print( std::cerr, *func, 2 );
+                                        )
+
+                                        // check if the type is a pointer to function
+                                        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( newFunc, function, argExpansions, found );
+                                                }
+                                        } else if ( 
+                                                auto inst = dynamic_cast< const ast::TypeInstType * >( funcResult ) 
+                                        ) {
+                                                if ( const ast::EqvClass * clz = func->env.lookup( inst->name ) ) {
+                                                        if ( auto function = clz->bound.as< ast::FunctionType >() ) {
+                                                                CandidateRef newFunc{ new Candidate{ *func } };
+                                                                newFunc->expr = 
+                                                                        referenceToRvalueConversion( newFunc->expr, newFunc->cost );
+                                                                makeFunctionCandidates( newFunc, function, argExpansions, found );
+                                                        }
+                                                }
+                                        }
+                                } catch ( SemanticErrorException & e ) { errors.append( e ); }
+                        }
+
+                        // Find matches on function operators `?()`
+                        if ( ! opFinder.candidates.empty() ) {
+                                // add exploded function alternatives to front of argument list
+                                std::vector< ExplodedArg > funcE;
+                                funcE.reserve( funcFinder.candidates.size() );
+                                for ( const CandidateRef & func : funcFinder ) { 
+                                        funcE.emplace_back( *func, symtab );
+                                }
+                                argExpansions.emplace_front( std::move( funcE ) );
+
+                                for ( const CandidateRef & op : opFinder ) {
+                                        try {
+                                                // check if type is pointer-to-function
+                                                const ast::Type * opResult = op->expr->result->stripReferences();
+                                                if ( auto pointer = dynamic_cast< const ast::PointerType * >( opResult ) ) {
+                                                        if ( auto function = pointer->base.as< ast::FunctionType >() ) {
+                                                                CandidateRef newOp{ new Candidate{ *op} };
+                                                                newOp->expr = 
+                                                                        referenceToRvalueConversion( newOp->expr, newOp->cost );
+                                                                makeFunctionCandidates( newOp, function, argExpansions, found );
+                                                        }
+                                                }
+                                        } catch ( SemanticErrorException & e ) { errors.append( e ); }
+                                }
+                        }
+
+                        // Implement SFINAE; resolution errors are only errors if there aren't any non-error 
+                        // candidates
+                        if ( found.empty() && ! errors.isEmpty() ) { throw errors; }
+
+                        // Compute conversion costs
+                        for ( CandidateRef & withFunc : found ) {
+                                Cost cvtCost = computeApplicationConversionCost( withFunc, symtab );
+
+                                PRINT(
+                                        auto appExpr = withFunc->expr.strict_as< ast::ApplicationExpr >();
+                                        auto pointer = appExpr->func->result.strict_as< ast::PointerType >();
+                                        auto function = pointer->base.strict_as< ast::FunctionType >();
+                                        
+                                        std::cerr << "Case +++++++++++++ " << appExpr->func << std::endl;
+                                        std::cerr << "parameters are:" << std::endl;
+                                        ast::printAll( std::cerr, function->params, 2 );
+                                        std::cerr << "arguments are:" << std::endl;
+                                        ast::printAll( std::cerr, appExpr->args, 2 );
+                                        std::cerr << "bindings are:" << std::endl;
+                                        ast::print( std::cerr, withFunc->env, 2 );
+                                        std::cerr << "cost is: " << withFunc->cost << std::endl;
+                                        std::cerr << "cost of conversion is:" << cvtCost << std::endl;
+                                )
+
+                                if ( cvtCost != Cost::infinity ) {
+                                        withFunc->cvtCost = cvtCost;
+                                        candidates.emplace_back( std::move( withFunc ) );
+                                }
+                        }
+                        found = std::move( candidates );
+
+                        // use a new list so that candidates are not examined by addAnonConversions twice
+                        CandidateList winners = findMinCost( found );
+                        promoteCvtCost( winners );
+
+                        // function may return a struct/union value, in which case we need to add candidates 
+                        // for implicit conversions to each of the anonymous members, which must happen after 
+                        // `findMinCost`, since anon conversions are never the cheapest
+                        for ( const CandidateRef & c : winners ) {
+                                addAnonConversions( c );
+                        }
+                        spliceBegin( candidates, winners );
+
+                        if ( candidates.empty() && targetType && ! targetType->isVoid() ) {
+                                // If resolution is unsuccessful with a target type, try again without, since it 
+                                // will sometimes succeed when it wouldn't with a target type binding.
+                                // For example:
+                                //   forall( otype T ) T & ?[]( T *, ptrdiff_t );
+                                //   const char * x = "hello world";
+                                //   unsigned char ch = x[0];
+                                // Fails with simple return type binding (xxx -- check this!) as follows:
+                                // * T is bound to unsigned char
+                                // * (x: const char *) is unified with unsigned char *, which fails
+                                // xxx -- fix this better
+                                targetType = nullptr;
+                                postvisit( untypedExpr );
+                        }
                 }
 
@@ -440 +635 @@
         }
 
-        /// Returns a list of alternatives with the minimum cost in the given list
-        CandidateList findMinCost( const CandidateList & candidates ) {
-                CandidateList out;
-                Cost minCost = Cost::infinity;
-                for ( const CandidateRef & r : candidates ) {
-                        if ( r->cost < minCost ) {
-                                minCost = r->cost;
-                                out.clear();
-                                out.emplace_back( r );
-                        } else if ( r->cost == minCost ) {
-                                out.emplace_back( r );
-                        }
-                }
-                return out;
-        }
-
 } // anonymous namespace