Changes in src/ResolvExpr/Resolver.cc [2fd9f24:2a6292d]

File:

• src/ResolvExpr/Resolver.cc (modified) (14 diffs)

src/ResolvExpr/Resolver.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:17:01 2015
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Fri Oct 05 09:43:00 2018
-// Update Count     : 214
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Feb 17 11:19:40 2018
+// Update Count     : 213
 //
 
+#include <stddef.h>                      // for NULL
 #include <cassert>                       // for strict_dynamic_cast, assert
 #include <memory>                        // for allocator, allocator_traits<...
 #include <tuple>                         // for get
-#include <vector>                        // for vector
+#include <vector>
 
 #include "Alternative.h"                 // for Alternative, AltList
@@ -30 +31 @@
 #include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
 #include "Resolver.h"
-#include "ResolvMode.h"                  // for ResolvMode
 #include "SymTab/Autogen.h"              // for SizeType
 #include "SymTab/Indexer.h"              // for Indexer
@@ -168 +168 @@
 
         namespace {
-                void findUnfinishedKindExpression(Expression * untyped, Alternative & alt, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, ResolvMode mode = ResolvMode{} ) {
+                void findUnfinishedKindExpression(Expression * untyped, Alternative & alt, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, bool adjust = false, bool prune = true, bool failFast = true) {
                         assertf( untyped, "expected a non-null expression." );
-
-                        // xxx - this isn't thread-safe, but should work until we parallelize the resolver
-                        static unsigned recursion_level = 0;
-
-                        ++recursion_level;
                         TypeEnvironment env;
                         AlternativeFinder finder( indexer, env );
-                        finder.find( untyped, recursion_level == 1 ? mode.atTopLevel() : mode );
-                        --recursion_level;
+                        finder.find( untyped, adjust, prune, failFast );
 
                         #if 0
@@ -191 +185 @@
                         #endif
 
-                        // produce filtered list of alternatives
                         AltList candidates;
                         for ( Alternative & alt : finder.get_alternatives() ) {
@@ -199 +192 @@
                         }
 
-                        // produce invalid error if no candidates
-                        if ( candidates.empty() ) {
+                        // xxx - if > 1 alternative with same cost, ignore deleted and pick from remaining
+                        // choose the lowest cost expression among the candidates
+                        AltList winners;
+                        findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
+                        if ( winners.size() == 0 ) {
                                 SemanticError( untyped, toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: ") );
-                        }
-
-                        // search for cheapest candidate
-                        AltList winners;
-                        bool seen_undeleted = false;
-                        for ( unsigned i = 0; i < candidates.size(); ++i ) {
-                                int c = winners.empty() ? -1 : candidates[i].cost.compare( winners.front().cost );
-
-                                if ( c > 0 ) continue; // skip more expensive than winner
-
-                                if ( c < 0 ) {
-                                        // reset on new cheapest
-                                        seen_undeleted = ! findDeletedExpr( candidates[i].expr );
-                                        winners.clear();
-                                } else /* if ( c == 0 ) */ {
-                                        if ( findDeletedExpr( candidates[i].expr ) ) {
-                                                // skip deleted expression if already seen one equivalent-cost not
-                                                if ( seen_undeleted ) continue;
-                                        } else if ( ! seen_undeleted ) {
-                                                // replace list of equivalent-cost deleted expressions with one non-deleted
-                                                winners.clear();
-                                                seen_undeleted = true;
-                                        }
-                                }
-
-                                winners.emplace_back( std::move( candidates[i] ) );
-                        }
-
-                        // promote alternative.cvtCost to .cost
-                        // xxx - I don't know why this is done, but I'm keeping the behaviour from findMinCost
-                        for ( Alternative& winner : winners ) {
-                                winner.cost = winner.cvtCost;
-                        }
-                        
-                        // produce ambiguous errors, if applicable
-                        if ( winners.size() != 1 ) {
+                        } else if ( winners.size() != 1 ) {
                                 std::ostringstream stream;
                                 stream << "Cannot choose between " << winners.size() << " alternatives for " << kindStr << (kindStr != "" ? " " : "") << "expression\n";
@@ -246 +207 @@
                         }
 
-                        // single selected choice
-                        Alternative& choice = winners.front();
-
-                        // fail on only expression deleted
-                        if ( ! seen_undeleted ) {
+                        // there is one unambiguous interpretation - move the expression into the with statement
+                        Alternative & choice = winners.front();
+                        if ( findDeletedExpr( choice.expr ) ) {
                                 SemanticError( untyped->location, choice.expr, "Unique best alternative includes deleted identifier in " );
                         }
-
-                        // xxx - check for ambiguous expressions
-                        
-                        // output selected choice
                         alt = std::move( choice );
                 }
 
                 /// resolve `untyped` to the expression whose alternative satisfies `pred` with the lowest cost; kindStr is used for providing better error messages
-                void findKindExpression(Expression *& untyped, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, ResolvMode mode = ResolvMode{}) {
+                void findKindExpression(Expression *& untyped, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, bool adjust = false, bool prune = true, bool failFast = true) {
                         if ( ! untyped ) return;
                         Alternative choice;
-                        findUnfinishedKindExpression( untyped, choice, indexer, kindStr, pred, mode );
+                        findUnfinishedKindExpression( untyped, choice, indexer, kindStr, pred, adjust, prune, failFast );
                         finishExpr( choice.expr, choice.env, untyped->env );
                         delete untyped;
@@ -295 +250 @@
                 untyped.arg = expr;
                 Alternative choice;
-                findUnfinishedKindExpression( &untyped, choice, indexer, "", standardAlternativeFilter, ResolvMode::withAdjustment() );
+                findUnfinishedKindExpression( &untyped, choice, indexer, "", standardAlternativeFilter, true );
                 CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( choice.expr );
                 env = std::move( choice.env );
@@ -402 +357 @@
 
         void Resolver::previsit( ObjectDecl *objectDecl ) {
-                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that 
-                // class-variable initContext is changed multiple time because the LHS is analysed twice. 
-                // The second analysis changes initContext because of a function type can contain object 
-                // declarations in the return and parameter types. So each value of initContext is 
-                // retained, so the type on the first analysis is preserved and used for selecting the RHS.
+                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that class-variable
+                // initContext is changed multiple time because the LHS is analysed twice. The second analysis changes
+                // initContext because of a function type can contain object declarations in the return and parameter types. So
+                // each value of initContext is retained, so the type on the first analysis is preserved and used for selecting
+                // the RHS.
                 GuardValue( currentObject );
                 currentObject = CurrentObject( objectDecl->get_type() );
@@ -442 +397 @@
 
         void Resolver::postvisit( FunctionDecl *functionDecl ) {
-                // default value expressions have an environment which shouldn't be there and trips up 
-                // later passes.
-                // xxx - it might be necessary to somehow keep the information from this environment, but I 
-                // can't currently see how it's useful.
+                // default value expressions have an environment which shouldn't be there and trips up later passes.
+                // xxx - it might be necessary to somehow keep the information from this environment, but I can't currently
+                // see how it's useful.
                 for ( Declaration * d : functionDecl->type->parameters ) {
                         if ( ObjectDecl * obj = dynamic_cast< ObjectDecl * >( d ) ) {
@@ -795 +749 @@
                 initExpr->expr = nullptr;
                 std::swap( initExpr->env, newExpr->env );
-                // InitExpr may have inferParams in the case where the expression specializes a function 
-                // pointer, and newExpr may already have inferParams of its own, so a simple swap is not 
-                // sufficient.
+                // InitExpr may have inferParams in the case where the expression specializes a function pointer,
+                // and newExpr may already have inferParams of its own, so a simple swap is not sufficient.
                 newExpr->spliceInferParams( initExpr );
                 delete initExpr;
 
-                // get the actual object's type (may not exactly match what comes back from the resolver 
-                // due to conversions)
+                // get the actual object's type (may not exactly match what comes back from the resolver due to conversions)
                 Type * initContext = currentObject.getCurrentType();
 
@@ -814 +766 @@
                                         if ( isCharType( pt->get_base() ) ) {
                                                 if ( CastExpr *ce = dynamic_cast< CastExpr * >( newExpr ) ) {
-                                                        // strip cast if we're initializing a char[] with a char *, 
-                                                        // e.g.  char x[] = "hello";
+                                                        // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
                                                         newExpr = ce->get_arg();
                                                         ce->set_arg( nullptr );
@@ -837 +788 @@
                 // move cursor into brace-enclosed initializer-list
                 currentObject.enterListInit();
-                // xxx - fix this so that the list isn't copied, iterator should be used to change current 
-                // element
+                // xxx - fix this so that the list isn't copied, iterator should be used to change current element
                 std::list<Designation *> newDesignations;
                 for ( auto p : group_iterate(listInit->get_designations(), listInit->get_initializers()) ) {
-                        // iterate designations and initializers in pairs, moving the cursor to the current 
-                        // designated object and resolving the initializer against that object.
+                        // iterate designations and initializers in pairs, moving the cursor to the current designated object and resolving
+                        // the initializer against that object.
                         Designation * des = std::get<0>(p);
                         Initializer * init = std::get<1>(p);
@@ -872 +822 @@
                 // fall back on C-style initializer
                 delete ctorInit->get_ctor();
-                ctorInit->set_ctor( nullptr );
+                ctorInit->set_ctor( NULL );
                 delete ctorInit->get_dtor();
-                ctorInit->set_dtor( nullptr );
+                ctorInit->set_dtor( NULL );
                 maybeAccept( ctorInit->get_init(), *visitor );
         }
@@ -917 +867 @@
 
                 // xxx - todo -- what about arrays?
-                // if ( dtor == nullptr && InitTweak::isIntrinsicCallStmt( ctorInit->get_ctor() ) ) {
+                // if ( dtor == NULL && InitTweak::isIntrinsicCallStmt( ctorInit->get_ctor() ) ) {
                 //      // can reduce the constructor down to a SingleInit using the
                 //      // second argument from the ctor call, since
                 //      delete ctorInit->get_ctor();
-                //      ctorInit->set_ctor( nullptr );
+                //      ctorInit->set_ctor( NULL );
 
                 //      Expression * arg =