Changeset 4edf753

Timestamp:

Mar 13, 2018, 2:17:10 PM (7 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

resolv-new

Parents:

8573729

Message:

Added deleted expression support to waitfor

File:

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

src/ResolvExpr/Resolver.cc ¶

@@ -19 +19 @@
 #include <memory>                        // for allocator, allocator_traits<...
 #include <tuple>                         // for get
+#include <utility>                       // for move
 #include <vector>
 
@@ -629 +630 @@
                         }
 
+                        assertf(func_candidates.size() == args_candidates.size(), 
+                                "Same number of function and argument candidates");
+                        
+                        // remove alternatives that include deleted expressions
+                        unsigned into = 0;
+                        for ( unsigned from = 0; from < func_candidates.size(); ++from ) {
+                                // skip deleted expressions
+                                if ( findDeletedExpr( func_candidates[from].expr ) 
+                                                || std::any_of( args_candidates[from].begin(), args_candidates[from].end(), 
+                                                        []( const Alternative& a ) { return findDeletedExpr( a.expr ); } ) ) {
+                                        continue;
+                                }
+
+                                // overwrite deleted candidates
+                                if ( into < from ) {
+                                        func_candidates[into] = std::move( func_candidates[from] );
+                                        args_candidates[into] = std::move( args_candidates[from] );
+                                }
+                                ++into;
+                        }
+                        bool includes_deleted = into < func_candidates.size();
+                        if ( includes_deleted ) {
+                                func_candidates.resize( into );
+                                args_candidates.resize( into );
+                        }
+
                         // Make sure we got the right number of arguments
-                        if( func_candidates.empty() )    { SemanticErrorException top( stmt->location, "No alternatives for function in call to waitfor"  ); top.append( errors ); throw top; }
-                        if( args_candidates.empty() )    { SemanticErrorException top( stmt->location, "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
-                        if( func_candidates.size() > 1 ) { SemanticErrorException top( stmt->location, "Ambiguous function in call to waitfor"            ); top.append( errors ); throw top; }
-                        if( args_candidates.size() > 1 ) { SemanticErrorException top( stmt->location, "Ambiguous arguments in call to waitfor"           ); top.append( errors ); throw top; }
-                        // TODO: need to use findDeletedExpr to ensure no deleted identifiers are used.
-
+                        if( func_candidates.empty() ) {
+                                SemanticErrorException top( stmt->location, includes_deleted ?
+                                        "No non-deleted alternatives for call to waitfor" :
+                                        "No alternatives for call to waitfor" );
+                                top.append( errors );
+                                throw top;
+                        }
+                        if( func_candidates.size() > 1 ) {
+                                SemanticErrorException top( stmt->location, 
+                                        "Ambiguous call to waitfor" );
+                                top.append( errors );
+                                throw top;
+                        }
+                        
                         // Swap the results from the alternative with the unresolved values.
                         // Alternatives will handle deletion on destruction