Changeset 396037d for src/ResolvExpr

Timestamp:

Jun 10, 2019, 6:02:36 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:

6ad19fd, d57e349

Parents:

5485e101

Message:

Start stubbing CandidateFinder? in

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (1 diff)
• CandidateFinder.cpp (modified) (2 diffs)
• CandidateFinder.hpp (modified) (2 diffs)
• ResolvMode.h (modified) (2 diffs)
• SatisfyAssertions.cpp (added)
• SatisfyAssertions.hpp (added)
• module.mk (modified) (1 diff)

src/ResolvExpr/AlternativeFinder.cc

@@ -266 +266 @@
                         SemanticError( expr, "No reasonable alternatives for expression " );
                 }
-                if ( mode.resolveAssns || mode.prune ) {
+                if ( mode.satisfyAssns || mode.prune ) {
                         // trim candidates just to those where the assertions resolve
                         // - necessary pre-requisite to pruning

src/ResolvExpr/CandidateFinder.cpp

@@ -16 +16 @@
 #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
-        (void)expr; (void)mode;
         assert(false);
 }
@@ -31 +116 @@
         std::vector< CandidateFinder > out;
 
-        #warning unimplemented
-        (void)xs;
-        assert(false);
+        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;

src/ResolvExpr/CandidateFinder.hpp

@@ -19 +19 @@
 #include "ResolvMode.h"
 #include "AST/Fwd.hpp"
+#include "AST/Node.hpp"
 #include "AST/SymbolTable.hpp"
 #include "AST/TypeEnvironment.hpp"
@@ -29 +30 @@
         const ast::SymbolTable & symtab;         ///< Symbol table to lookup candidates
         const ast::TypeEnvironment & env;        ///< Substitutions performed in this resolution
-        const ast::Type * targetType = nullptr;  ///< Target type for resolution
+        ast::ptr< ast::Type > targetType = nullptr;  ///< Target type for resolution
 
         CandidateFinder( const ast::SymbolTable & symtab, const ast::TypeEnvironment & env )

src/ResolvExpr/ResolvMode.h

@@ -22 +22 @@
                 const bool prune;            ///< Prune alternatives to min-cost per return type? [true]
                 const bool failFast;         ///< Fail on no resulting alternatives? [true]
-                const bool resolveAssns;     ///< Resolve assertions? [false]
+                const bool satisfyAssns;     ///< Satisfy assertions? [false]
 
         private:
-                constexpr ResolvMode(bool a, bool p, bool ff, bool ra) 
-                : adjust(a), prune(p), failFast(ff), resolveAssns(ra) {}
+                constexpr ResolvMode(bool a, bool p, bool ff, bool sa) 
+                : adjust(a), prune(p), failFast(ff), satisfyAssns(sa) {}
 
         public:
                 /// Default settings
-                constexpr ResolvMode() : adjust(false), prune(true), failFast(true), resolveAssns(false) {}
+                constexpr ResolvMode() : adjust(false), prune(true), failFast(true), satisfyAssns(false) {}
                 
                 /// With adjust flag set; turns array and function types into equivalent pointers
@@ -43 +43 @@
                 static constexpr ResolvMode withoutFailFast() { return { true, true, false, false }; }
 
-                /// The same mode, but with resolveAssns turned on; for top-level calls
+                /// The same mode, but with satisfyAssns turned on; for top-level calls
                 ResolvMode atTopLevel() const { return { adjust, prune, failFast, true }; }
         };

src/ResolvExpr/module.mk

@@ -35 +35 @@
       ResolvExpr/Resolver.cc \
       ResolvExpr/ResolveTypeof.cc \
+      ResolvExpr/SatisfyAssertions.cpp \
       ResolvExpr/SpecCost.cc \
       ResolvExpr/TypeEnvironment.cc \