Changes in src/ResolvExpr/Resolver.cc [c71b256:d55d7a6]

File:

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

src/ResolvExpr/Resolver.cc

@@ -105 +105 @@
         }
 
-        namespace {
-                struct DeleteFinder : public WithShortCircuiting        {
-                        DeletedExpr * delExpr = nullptr;
-                        void previsit( DeletedExpr * expr ) {
-                                if ( delExpr ) visit_children = false;
-                                else delExpr = expr;
-                        }
-
-                        void previsit( Expression * ) {
-                                if ( delExpr ) visit_children = false;
-                        }
-                };
-        }
-
-        DeletedExpr * findDeletedExpr( Expression * expr ) {
-                PassVisitor<DeleteFinder> finder;
-                expr->accept( finder );
-                return finder.pass.delExpr;
+        // used in resolveTypeof
+        Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer ) {
+                TypeEnvironment env;
+                return resolveInVoidContext( expr, indexer, env );
         }
 
@@ -144 +130 @@
         } // namespace
 
-        namespace {
-                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." );
-                        TypeEnvironment env;
-                        AlternativeFinder finder( indexer, env );
-                        finder.find( untyped, adjust, prune, failFast );
-
-                        #if 0
-                        if ( finder.get_alternatives().size() != 1 ) {
-                                std::cerr << "untyped expr is ";
-                                untyped->print( std::cerr );
-                                std::cerr << std::endl << "alternatives are:";
-                                for ( const Alternative & alt : finder.get_alternatives() ) {
-                                        alt.print( std::cerr );
-                                } // for
-                        } // if
-                        #endif
-
-                        AltList candidates;
-                        for ( Alternative & alt : finder.get_alternatives() ) {
-                                if ( pred( alt ) ) {
-                                        candidates.push_back( std::move( alt ) );
-                                }
-                        }
-
-                        // 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 ) {
-                                throw SemanticError( toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: "), untyped );
-                        } else if ( winners.size() != 1 ) {
-                                std::ostringstream stream;
-                                stream << "Cannot choose between " << winners.size() << " alternatives for " << kindStr << (kindStr != "" ? " " : "") << "expression\n";
-                                untyped->print( stream );
-                                stream << "Alternatives are:\n";
-                                printAlts( winners, stream, 1 );
-                                throw SemanticError( stream.str() );
-                        }
-
-                        // there is one unambiguous interpretation - move the expression into the with statement
-                        Alternative & choice = winners.front();
-                        if ( findDeletedExpr( choice.expr ) ) {
-                                throw SemanticError( "Unique best alternative includes deleted identifier in ", choice.expr );
-                        }
-                        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, bool adjust = false, bool prune = true, bool failFast = true) {
-                        if ( ! untyped ) return;
-                        Alternative choice;
-                        findUnfinishedKindExpression( untyped, choice, indexer, kindStr, pred, adjust, prune, failFast );
-                        finishExpr( choice.expr, choice.env, untyped->env );
-                        delete untyped;
-                        untyped = choice.expr;
-                        choice.expr = nullptr;
-                }
-
-                bool standardAlternativeFilter( const Alternative & ) {
-                        // currently don't need to filter, under normal circumstances.
-                        // in the future, this may be useful for removing deleted expressions
-                        return true;
-                }
-        } // namespace
-
-        // used in resolveTypeof
-        Expression * resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer ) {
-                TypeEnvironment env;
-                return resolveInVoidContext( expr, indexer, env );
-        }
-
-        Expression * resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env ) {
-                // it's a property of the language that a cast expression has either 1 or 0 interpretations; if it has 0
-                // interpretations, an exception has already been thrown.
-                assertf( expr, "expected a non-null expression." );
-
-                static CastExpr untyped( nullptr ); // cast to void
-
-                // set up and resolve expression cast to void
-                untyped.arg = expr;
-                Alternative choice;
-                findUnfinishedKindExpression( &untyped, choice, indexer, "", standardAlternativeFilter, true );
-                CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( choice.expr );
-                env = std::move( choice.env );
-
-                // clean up resolved expression
-                Expression * ret = castExpr->arg;
-                castExpr->arg = nullptr;
-
-                // unlink the arg so that it isn't deleted twice at the end of the program
-                untyped.arg = nullptr;
-                return ret;
-        }
-
         void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
                 resetTyVarRenaming();
                 TypeEnvironment env;
-                Expression * newExpr = resolveInVoidContext( untyped, indexer, env );
+                Expression *newExpr = resolveInVoidContext( untyped, indexer, env );
                 finishExpr( newExpr, env, untyped->env );
                 delete untyped;
@@ -249 +140 @@
 
         void findSingleExpression( Expression *&untyped, const SymTab::Indexer &indexer ) {
-                findKindExpression( untyped, indexer, "", standardAlternativeFilter );
+                if ( ! untyped ) return;
+                TypeEnvironment env;
+                AlternativeFinder finder( indexer, env );
+                finder.find( untyped );
+                #if 0
+                if ( finder.get_alternatives().size() != 1 ) {
+                        std::cerr << "untyped expr is ";
+                        untyped->print( std::cerr );
+                        std::cerr << std::endl << "alternatives are:";
+                        for ( const Alternative & alt : finder.get_alternatives() ) {
+                                alt.print( std::cerr );
+                        } // for
+                } // if
+                #endif
+                assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end: (%zd) %s", finder.get_alternatives().size(), toString( untyped ).c_str() );
+                Alternative &choice = finder.get_alternatives().front();
+                Expression *newExpr = choice.expr->clone();
+                finishExpr( newExpr, choice.env, untyped->env );
+                delete untyped;
+                untyped = newExpr;
         }
 
@@ -260 +170 @@
 
         namespace {
-                bool isIntegralType( const Alternative & alt ) {
-                        Type * type = alt.expr->result;
+                /// resolve `untyped` to the expression whose type satisfies `pred` with the lowest cost; kindStr is used for providing better error messages
+                template<typename Pred>
+                void findKindExpression(Expression *& untyped, const SymTab::Indexer & indexer, const std::string & kindStr, Pred pred) {
+                        TypeEnvironment env;
+                        AlternativeFinder finder( indexer, env );
+                        finder.findWithAdjustment( untyped );
+
+                        AltList candidates;
+                        for ( Alternative & alt : finder.get_alternatives() ) {
+                                if ( pred( alt.expr->result ) ) {
+                                        candidates.push_back( std::move( alt ) );
+                                }
+                        }
+
+                        // choose the lowest cost expression among the candidates
+                        AltList winners;
+                        findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
+                        if ( winners.size() == 0 ) {
+                                throw SemanticError( untyped, "No reasonable alternatives for " + kindStr + " expression: " );
+                        } else if ( winners.size() != 1 ) {
+                                std::ostringstream stream;
+                                stream << "Cannot choose between " << winners.size() << " alternatives for " + kindStr +  " expression\n";
+                                untyped->print( stream );
+                                stream << "Alternatives are:\n";
+                                printAlts( winners, stream, 1 );
+                                throw SemanticError( untyped->location, stream.str() );
+                        }
+
+                        // there is one unambiguous interpretation - move the expression into the with statement
+                        Alternative & alt = winners.front();
+                        finishExpr( alt.expr, alt.env, untyped->env );
+                        delete untyped;
+                        untyped = alt.expr;
+                        alt.expr = nullptr;
+                }
+
+                bool isIntegralType( Type *type ) {
                         if ( dynamic_cast< EnumInstType * >( type ) ) {
                                 return true;
@@ -484 +429 @@
                                 ss << strict_dynamic_cast<NameExpr*>( clause.target.function )->name;
                                 ss << "' in call to waitfor";
-                                throw SemanticError( ss.str() );
+                                throw SemanticError( stmt->location, ss.str() );
                         }
 
@@ -506 +451 @@
                                         PointerType * pointer = dynamic_cast< PointerType* >( func.expr->get_result()->stripReferences() );
                                         if( !pointer ) {
-                                                throw SemanticError( "candidate not viable: not a pointer type\n", func.expr->get_result() );
+                                                throw SemanticError( func.expr->get_result(), "candidate not viable: not a pointer type\n" );
                                         }
 
                                         FunctionType * function = dynamic_cast< FunctionType* >( pointer->get_base() );
                                         if( !function ) {
-                                                throw SemanticError( "candidate not viable: not a function type\n", pointer->get_base() );
+                                                throw SemanticError( pointer->get_base(), "candidate not viable: not a function type\n" );
                                         }
 
@@ -520 +465 @@
 
                                                 if( !advance_to_mutex( param, param_end ) ) {
-                                                        throw SemanticError("candidate function not viable: no mutex parameters\n", function);
+                                                        throw SemanticError(function, "candidate function not viable: no mutex parameters\n");
                                                 }
                                         }
@@ -559 +504 @@
                                                                         // We ran out of parameters but still have arguments
                                                                         // this function doesn't match
-                                                                        throw SemanticError("candidate function not viable: too many mutex arguments\n", function);
+                                                                        throw SemanticError( function, "candidate function not viable: too many mutex arguments\n" );
                                                                 }
 
@@ -571 +516 @@
                                                                         (*param)->get_type()->print( ss );
                                                                         ss << "'\n";
-                                                                        throw SemanticError(ss.str(), function);
+                                                                        throw SemanticError( function, ss.str() );
                                                                 }
 
@@ -583 +528 @@
                                                                 // We ran out of arguments but still have parameters left
                                                                 // this function doesn't match
-                                                                throw SemanticError("candidate function not viable: too few mutex arguments\n", function);
+                                                                throw SemanticError( function, "candidate function not viable: too few mutex arguments\n" );
                                                         }
 
@@ -610 +555 @@
 
                         // Make sure we got the right number of arguments
-                        if( func_candidates.empty() )    { SemanticError top( "No alternatives for function in call to waitfor"  ); top.append( errors ); throw top; }
-                        if( args_candidates.empty() )    { SemanticError top( "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
-                        if( func_candidates.size() > 1 ) { SemanticError top( "Ambiguous function in call to waitfor"            ); top.append( errors ); throw top; }
-                        if( args_candidates.size() > 1 ) { SemanticError top( "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() )    { SemanticError top( stmt->location, "No alternatives for function in call to waitfor"  ); top.append( errors ); throw top; }
+                        if( args_candidates.empty() )    { SemanticError top( stmt->location, "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
+                        if( func_candidates.size() > 1 ) { SemanticError top( stmt->location, "Ambiguous function in call to waitfor"            ); top.append( errors ); throw top; }
+                        if( args_candidates.size() > 1 ) { SemanticError top( stmt->location, "Ambiguous arguments in call to waitfor"           ); top.append( errors ); throw top; }
+
 
                         // Swap the results from the alternative with the unresolved values.
@@ -647 +592 @@
         }
 
-        bool isStructOrUnion( const Alternative & alt ) {
-                Type * t = alt.expr->result->stripReferences();
+        bool isStructOrUnion( Type * t ) {
+                t = t->stripReferences();
                 return dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t );
         }