Changeset 8573729 for src/ResolvExpr

Timestamp:

Mar 12, 2018, 5:28:11 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

resolv-new

Children:

4edf753

Parents:

6171841

Message:

Start new assertion resolution branch

• assertion resolution visitor is stubbed in
• ignores equally-minimal deleted expressions

Location:

src/ResolvExpr

Files:

• ResolveAssertions.cc (added)
• ResolveAssertions.h (added)
• Resolver.cc (modified) (6 diffs)
• module.mk (modified) (1 diff)

src/ResolvExpr/Resolver.cc

@@ -15 +15 @@
 
 #include <stddef.h>                      // for NULL
+#include <algorithm>                     // for sort
 #include <cassert>                       // for strict_dynamic_cast, assert
 #include <memory>                        // for allocator, allocator_traits<...
@@ -29 +30 @@
 #include "InitTweak/InitTweak.h"         // for isIntrinsicSingleArgCallStmt
 #include "RenameVars.h"                  // for RenameVars, global_renamer
+#include "ResolveAssertions.h"           // for resolveAssertions
 #include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
 #include "ResolveTypeof.h"               // for resolveTypeof
@@ -169 +171 @@
                         }
 
-                        // xxx - if > 1 alternative with same cost, ignore deleted and pick from remaining
-                        // choose the lowest cost expression among the candidates
+                        // sort candidates by cost
+                        std::sort( candidates.begin(), candidates.end(), 
+                                [](const Alternative& a, const Alternative& b) { return a.cost < b.cost; } );
+                        // search for cheapest resolvable candidate
                         AltList winners;
-                        findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
+                        for ( const Alternative& r : candidates ) {
+                                if ( ! winners.empty() ) {
+                                        // break if already have a cheaper candidate
+                                        if ( winners[0].cost < r.cost ) break;
+
+                                        // ignore min-cost deleted alternatives if already found one alternative
+                                        if ( findDeletedExpr( r.expr ) ) continue;
+                                }
+                                
+                                // check candidate assertion resolution
+                                if ( resolveAssertions( r.expr ) ) {
+                                        winners.push_back( r );
+                                }
+                        }
+                        
                         if ( winners.size() == 0 ) {
                                 SemanticError( untyped, toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: ") );
@@ -281 +299 @@
                 Type *new_type = resolveTypeof( objectDecl->get_type(), indexer );
                 objectDecl->set_type( new_type );
-                // 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() );
@@ -329 +347 @@
 
                 {
-                        // resolve with-exprs with parameters in scope and add any newly generated declarations to the
-                        // front of the function body.
-                        auto guard = makeFuncGuard( [this]() { indexer.enterScope(); }, [this](){ indexer.leaveScope(); } );
+                        // resolve with-exprs with parameters in scope and add any newly generated declarations 
+                        // to the front of the function body.
+                        auto guard = makeFuncGuard( 
+                                [this]() { indexer.enterScope(); }, [this](){ indexer.leaveScope(); } );
                         indexer.addFunctionType( functionDecl->type );
                         std::list< Statement * > newStmts;
@@ -344 +363 @@
 
         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 ) ) {

src/ResolvExpr/module.mk

@@ -33 +33 @@
        ResolvExpr/TypeEnvironment.cc \
        ResolvExpr/CurrentObject.cc \
-       ResolvExpr/ExplodedActual.cc
+       ResolvExpr/ExplodedActual.cc \
+       ResolvExpr/ResolveAssertions.cc