source: src/ResolvExpr/CandidateFinder.cpp @ 396037d

//
// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// CandidateFinder.cpp --
//
// Author           : Aaron B. Moss
// Created On       : Wed Jun 5 14:30:00 2019
// Last Modified By : Aaron B. Moss
// Last Modified On : Wed Jun 5 14:30:00 2019
// Update Count     : 1
//

#include "CandidateFinder.hpp"

#include <sstream>

#include "Candidate.hpp"
#include "CompilationState.h"
#include "SatisfyAssertions.hpp"
#include "AST/Expr.hpp"
#include "AST/Node.hpp"
#include "AST/Pass.hpp"

#define PRINT( text ) if ( resolvep ) { text }

namespace ResolvExpr {

namespace {

        /// Actually visits expressions to find their candidate interpretations
        struct Finder {
                CandidateFinder & candFinder;
                const ast::SymbolTable & symtab;
                CandidateList & candidates;
                const ast::TypeEnvironment & tenv;
                ast::ptr< ast::Type > & targetType;

                Finder( CandidateFinder & f )
                : candFinder( f ), symtab( f.symtab ), candidates( f.candidates ), tenv( f.env ), 
                  targetType( f.targetType ) {}
                
                #warning unimplemented
        };

        /// Prunes a list of candidates down to those that have the minimum conversion cost for a given 
        /// return type. Skips ambiguous candidates.
        CandidateList pruneCandidates( CandidateList & candidates ) {
                #warning unimplemented
                (void)candidates;
                assert(false);
                return {};
        }

} // anonymous namespace

void CandidateFinder::find( const ast::Expr * expr, ResolvMode mode ) {
        // Find alternatives for expression
        ast::Pass<Finder> finder{ *this };
        expr->accept( finder );

        if ( mode.failFast && candidates.empty() ) {
                SemanticError( expr, "No reasonable alternatives for expression " );
        }

        if ( mode.satisfyAssns || mode.prune ) {
                // trim candidates to just those where the assertions are satisfiable
                // - necessary pre-requisite to pruning
                CandidateList satisfied;
                std::vector< std::string > errors;
                for ( auto & candidate : candidates ) {
                        satisfyAssertions( *candidate, symtab, satisfied, errors );
                }

                // fail early if none such
                if ( mode.failFast && satisfied.empty() ) {
                        std::ostringstream stream;
                        stream << "No alternatives with satisfiable assertions for " << expr << "\n";
                        for ( const auto& err : errors ) {
                                stream << err;
                        }
                        SemanticError( expr->location, stream.str() );
                }

                // reset candidates
                candidates = std::move( satisfied );
        }

        if ( mode.prune ) {
                // trim candidates to single best one
                auto oldsize = candidates.size();
                PRINT(
                        std::cerr << "alternatives before prune:" << std::endl;
                        print( std::cerr, candidates );
                )

                CandidateList pruned = pruneCandidates( candidates );
                if ( mode.failFast && pruned.empty() ) {
                        std::ostringstream stream;
                        CandidateList winners;
                        
                        #warning unimplemented
                        assert(false);
                }
        }

        #warning unimplemented
        assert(false);
}

std::vector< CandidateFinder > CandidateFinder::findSubExprs( 
        const std::vector< ast::ptr< ast::Expr > > & xs 
) {
        std::vector< CandidateFinder > out;

        for ( const auto & x : xs ) {
                out.emplace_back( symtab, env );
                out.back().find( x, ResolvMode::withAdjustment() );
                
                PRINT(
                        std::cerr << "findSubExprs" << std::endl;
                        print( std::cerr, out.back().candidates );
                )
        }

        return out;
}

} // namespace ResolvExpr

// Local Variables: //
// tab-width: 4 //
// mode: c++ //
// compile-command: "make install" //
// End: //