Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision 78754d782a2b5ad40158459a92881261efa9c6b2) +++ src/ResolvExpr/AlternativeFinder.cc (revision 13deae882b49c1c60e1d33ad6958f7f9a92fb9ee) @@ -60,4 +60,65 @@ namespace ResolvExpr { + struct AlternativeFinder::Finder : public WithShortCircuiting { + Finder( AlternativeFinder & altFinder ) : altFinder( altFinder ), indexer( altFinder.indexer ), alternatives( altFinder.alternatives ), env( altFinder.env ), targetType( altFinder.targetType ) {} + + void previsit( BaseSyntaxNode * ) { visit_children = false; } + + void postvisit( ApplicationExpr * applicationExpr ); + void postvisit( UntypedExpr * untypedExpr ); + void postvisit( AddressExpr * addressExpr ); + void postvisit( LabelAddressExpr * labelExpr ); + void postvisit( CastExpr * castExpr ); + void postvisit( VirtualCastExpr * castExpr ); + void postvisit( UntypedMemberExpr * memberExpr ); + void postvisit( MemberExpr * memberExpr ); + void postvisit( NameExpr * variableExpr ); + void postvisit( VariableExpr * variableExpr ); + void postvisit( ConstantExpr * constantExpr ); + void postvisit( SizeofExpr * sizeofExpr ); + void postvisit( AlignofExpr * alignofExpr ); + void postvisit( UntypedOffsetofExpr * offsetofExpr ); + void postvisit( OffsetofExpr * offsetofExpr ); + void postvisit( OffsetPackExpr * offsetPackExpr ); + void postvisit( AttrExpr * attrExpr ); + void postvisit( LogicalExpr * logicalExpr ); + void postvisit( ConditionalExpr * conditionalExpr ); + void postvisit( CommaExpr * commaExpr ); + void postvisit( ImplicitCopyCtorExpr * impCpCtorExpr ); + void postvisit( ConstructorExpr * ctorExpr ); + void postvisit( RangeExpr * rangeExpr ); + void postvisit( UntypedTupleExpr * tupleExpr ); + void postvisit( TupleExpr * tupleExpr ); + void postvisit( TupleIndexExpr * tupleExpr ); + void postvisit( TupleAssignExpr * tupleExpr ); + void postvisit( UniqueExpr * unqExpr ); + void postvisit( StmtExpr * stmtExpr ); + void postvisit( UntypedInitExpr * initExpr ); + + /// Adds alternatives for anonymous members + void addAnonConversions( const Alternative & alt ); + /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member + template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ); + /// Adds alternatives for member expressions where the left side has tuple type + void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ); + /// Adds alternatives for offsetof expressions, given the base type and name of the member + template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name ); + /// Takes a final result and checks if its assertions can be satisfied + template + void validateFunctionAlternative( const Alternative &func, ArgPack& result, const std::vector& results, OutputIterator out ); + /// Finds matching alternatives for a function, given a set of arguments + template + void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const ExplodedArgs& args, OutputIterator out ); + /// Checks if assertion parameters match for a new alternative + template< typename OutputIterator > + void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ); + private: + AlternativeFinder & altFinder; + const SymTab::Indexer &indexer; + AltList & alternatives; + const TypeEnvironment &env; + Type *& targetType; + }; + Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env ) { CastExpr *castToVoid = new CastExpr( expr ); @@ -185,5 +246,6 @@ void AlternativeFinder::find( Expression *expr, bool adjust, bool prune, bool failFast ) { - expr->accept( *this ); + PassVisitor finder( *this ); + expr->accept( finder ); if ( failFast && alternatives.empty() ) { PRINT( @@ -244,5 +306,5 @@ } - void AlternativeFinder::addAnonConversions( const Alternative & alt ) { + void AlternativeFinder::Finder::addAnonConversions( const Alternative & alt ) { // adds anonymous member interpretations whenever an aggregate value type is seen. // it's okay for the aggregate expression to have reference type -- cast it to the base type to treat the aggregate as the referenced value @@ -265,5 +327,5 @@ template< typename StructOrUnionType > - void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) { + void AlternativeFinder::Finder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) { // by this point, member must be a name expr NameExpr * nameExpr = dynamic_cast< NameExpr * >( member ); @@ -284,5 +346,5 @@ } - void AlternativeFinder::addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) { + void AlternativeFinder::Finder::addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) { if ( ConstantExpr * constantExpr = dynamic_cast< ConstantExpr * >( member ) ) { // get the value of the constant expression as an int, must be between 0 and the length of the tuple type to have meaning @@ -308,5 +370,5 @@ } - void AlternativeFinder::visit( ApplicationExpr *applicationExpr ) { + void AlternativeFinder::Finder::postvisit( ApplicationExpr *applicationExpr ) { alternatives.push_back( Alternative( applicationExpr->clone(), env, Cost::zero ) ); } @@ -541,5 +603,5 @@ template< typename OutputIterator > - void AlternativeFinder::inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ) { + void AlternativeFinder::Finder::inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ) { // PRINT( // std::cerr << "inferParameters: assertions needed are" << std::endl; @@ -892,5 +954,5 @@ template - void AlternativeFinder::validateFunctionAlternative( const Alternative &func, ArgPack& result, + void AlternativeFinder::Finder::validateFunctionAlternative( const Alternative &func, ArgPack& result, const std::vector& results, OutputIterator out ) { ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() ); @@ -915,5 +977,5 @@ template - void AlternativeFinder::makeFunctionAlternatives( const Alternative &func, + void AlternativeFinder::Finder::makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const ExplodedArgs &args, OutputIterator out ) { OpenVarSet funcOpenVars; @@ -1022,5 +1084,5 @@ } - void AlternativeFinder::visit( UntypedExpr *untypedExpr ) { + void AlternativeFinder::Finder::postvisit( UntypedExpr *untypedExpr ) { AlternativeFinder funcFinder( indexer, env ); funcFinder.findWithAdjustment( untypedExpr->get_function() ); @@ -1029,10 +1091,10 @@ std::vector< AlternativeFinder > argAlternatives; - findSubExprs( untypedExpr->begin_args(), untypedExpr->end_args(), + altFinder.findSubExprs( untypedExpr->begin_args(), untypedExpr->end_args(), back_inserter( argAlternatives ) ); // take care of possible tuple assignments // if not tuple assignment, assignment is taken care of as a normal function call - Tuples::handleTupleAssignment( *this, untypedExpr, argAlternatives ); + Tuples::handleTupleAssignment( altFinder, untypedExpr, argAlternatives ); // find function operators @@ -1172,5 +1234,5 @@ // fix this issue in a more robust way. targetType = nullptr; - visit( untypedExpr ); + postvisit( untypedExpr ); } } @@ -1181,5 +1243,5 @@ } - void AlternativeFinder::visit( AddressExpr *addressExpr ) { + void AlternativeFinder::Finder::postvisit( AddressExpr *addressExpr ) { AlternativeFinder finder( indexer, env ); finder.find( addressExpr->get_arg() ); @@ -1192,5 +1254,5 @@ } - void AlternativeFinder::visit( LabelAddressExpr * expr ) { + void AlternativeFinder::Finder::postvisit( LabelAddressExpr * expr ) { alternatives.push_back( Alternative{ expr->clone(), env, Cost::zero } ); } @@ -1223,5 +1285,5 @@ } - void AlternativeFinder::visit( CastExpr *castExpr ) { + void AlternativeFinder::Finder::postvisit( CastExpr *castExpr ) { Type *& toType = castExpr->get_result(); assert( toType ); @@ -1278,5 +1340,5 @@ } - void AlternativeFinder::visit( VirtualCastExpr * castExpr ) { + void AlternativeFinder::Finder::postvisit( VirtualCastExpr * castExpr ) { assertf( castExpr->get_result(), "Implicate virtual cast targets not yet supported." ); AlternativeFinder finder( indexer, env ); @@ -1290,5 +1352,5 @@ } - void AlternativeFinder::visit( UntypedMemberExpr *memberExpr ) { + void AlternativeFinder::Finder::postvisit( UntypedMemberExpr *memberExpr ) { AlternativeFinder funcFinder( indexer, env ); funcFinder.findWithAdjustment( memberExpr->get_aggregate() ); @@ -1312,9 +1374,9 @@ } - void AlternativeFinder::visit( MemberExpr *memberExpr ) { + void AlternativeFinder::Finder::postvisit( MemberExpr *memberExpr ) { alternatives.push_back( Alternative( memberExpr->clone(), env, Cost::zero ) ); } - void AlternativeFinder::visit( NameExpr *nameExpr ) { + void AlternativeFinder::Finder::postvisit( NameExpr *nameExpr ) { std::list< SymTab::Indexer::IdData > declList; indexer.lookupId( nameExpr->get_name(), declList ); @@ -1337,5 +1399,5 @@ } - void AlternativeFinder::visit( VariableExpr *variableExpr ) { + void AlternativeFinder::Finder::postvisit( VariableExpr *variableExpr ) { // not sufficient to clone here, because variable's type may have changed // since the VariableExpr was originally created. @@ -1343,9 +1405,9 @@ } - void AlternativeFinder::visit( ConstantExpr *constantExpr ) { + void AlternativeFinder::Finder::postvisit( ConstantExpr *constantExpr ) { alternatives.push_back( Alternative( constantExpr->clone(), env, Cost::zero ) ); } - void AlternativeFinder::visit( SizeofExpr *sizeofExpr ) { + void AlternativeFinder::Finder::postvisit( SizeofExpr *sizeofExpr ) { if ( sizeofExpr->get_isType() ) { Type * newType = sizeofExpr->get_type()->clone(); @@ -1368,5 +1430,5 @@ } - void AlternativeFinder::visit( AlignofExpr *alignofExpr ) { + void AlternativeFinder::Finder::postvisit( AlignofExpr *alignofExpr ) { if ( alignofExpr->get_isType() ) { Type * newType = alignofExpr->get_type()->clone(); @@ -1390,5 +1452,5 @@ template< typename StructOrUnionType > - void AlternativeFinder::addOffsetof( StructOrUnionType *aggInst, const std::string &name ) { + void AlternativeFinder::Finder::addOffsetof( StructOrUnionType *aggInst, const std::string &name ) { std::list< Declaration* > members; aggInst->lookup( name, members ); @@ -1403,5 +1465,5 @@ } - void AlternativeFinder::visit( UntypedOffsetofExpr *offsetofExpr ) { + void AlternativeFinder::Finder::postvisit( UntypedOffsetofExpr *offsetofExpr ) { AlternativeFinder funcFinder( indexer, env ); // xxx - resolveTypeof? @@ -1413,9 +1475,9 @@ } - void AlternativeFinder::visit( OffsetofExpr *offsetofExpr ) { + void AlternativeFinder::Finder::postvisit( OffsetofExpr *offsetofExpr ) { alternatives.push_back( Alternative( offsetofExpr->clone(), env, Cost::zero ) ); } - void AlternativeFinder::visit( OffsetPackExpr *offsetPackExpr ) { + void AlternativeFinder::Finder::postvisit( OffsetPackExpr *offsetPackExpr ) { alternatives.push_back( Alternative( offsetPackExpr->clone(), env, Cost::zero ) ); } @@ -1444,5 +1506,5 @@ } - void AlternativeFinder::visit( AttrExpr *attrExpr ) { + void AlternativeFinder::Finder::postvisit( AttrExpr *attrExpr ) { // assume no 'pointer-to-attribute' NameExpr *nameExpr = dynamic_cast< NameExpr* >( attrExpr->get_attr() ); @@ -1458,5 +1520,5 @@ if ( function->get_parameters().size() == 1 ) { if ( attrExpr->get_isType() ) { - resolveAttr( data, function, attrExpr->get_type(), env, *this ); + resolveAttr( data, function, attrExpr->get_type(), env, altFinder); } else { AlternativeFinder finder( indexer, env ); @@ -1464,5 +1526,5 @@ for ( AltList::iterator choice = finder.alternatives.begin(); choice != finder.alternatives.end(); ++choice ) { if ( choice->expr->get_result()->size() == 1 ) { - resolveAttr(data, function, choice->expr->get_result(), choice->env, *this ); + resolveAttr(data, function, choice->expr->get_result(), choice->env, altFinder ); } // fi } // for @@ -1479,5 +1541,5 @@ } - void AlternativeFinder::visit( LogicalExpr *logicalExpr ) { + void AlternativeFinder::Finder::postvisit( LogicalExpr *logicalExpr ) { AlternativeFinder firstFinder( indexer, env ); firstFinder.findWithAdjustment( logicalExpr->get_arg1() ); @@ -1492,5 +1554,5 @@ } - void AlternativeFinder::visit( ConditionalExpr *conditionalExpr ) { + void AlternativeFinder::Finder::postvisit( ConditionalExpr *conditionalExpr ) { // find alternatives for condition AlternativeFinder firstFinder( indexer, env ); @@ -1524,5 +1586,5 @@ } - void AlternativeFinder::visit( CommaExpr *commaExpr ) { + void AlternativeFinder::Finder::postvisit( CommaExpr *commaExpr ) { TypeEnvironment newEnv( env ); Expression *newFirstArg = resolveInVoidContext( commaExpr->get_arg1(), indexer, newEnv ); @@ -1535,5 +1597,5 @@ } - void AlternativeFinder::visit( RangeExpr * rangeExpr ) { + void AlternativeFinder::Finder::postvisit( RangeExpr * rangeExpr ) { // resolve low and high, accept alternatives whose low and high types unify AlternativeFinder firstFinder( indexer, env ); @@ -1557,7 +1619,7 @@ } - void AlternativeFinder::visit( UntypedTupleExpr *tupleExpr ) { + void AlternativeFinder::Finder::postvisit( UntypedTupleExpr *tupleExpr ) { std::vector< AlternativeFinder > subExprAlternatives; - findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(), + altFinder.findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(), back_inserter( subExprAlternatives ) ); std::vector< AltList > possibilities; @@ -1575,13 +1637,13 @@ } - void AlternativeFinder::visit( TupleExpr *tupleExpr ) { + void AlternativeFinder::Finder::postvisit( TupleExpr *tupleExpr ) { alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) ); } - void AlternativeFinder::visit( ImplicitCopyCtorExpr * impCpCtorExpr ) { + void AlternativeFinder::Finder::postvisit( ImplicitCopyCtorExpr * impCpCtorExpr ) { alternatives.push_back( Alternative( impCpCtorExpr->clone(), env, Cost::zero ) ); } - void AlternativeFinder::visit( ConstructorExpr * ctorExpr ) { + void AlternativeFinder::Finder::postvisit( ConstructorExpr * ctorExpr ) { AlternativeFinder finder( indexer, env ); // don't prune here, since it's guaranteed all alternatives will have the same type @@ -1593,13 +1655,13 @@ } - void AlternativeFinder::visit( TupleIndexExpr *tupleExpr ) { + void AlternativeFinder::Finder::postvisit( TupleIndexExpr *tupleExpr ) { alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) ); } - void AlternativeFinder::visit( TupleAssignExpr *tupleAssignExpr ) { + void AlternativeFinder::Finder::postvisit( TupleAssignExpr *tupleAssignExpr ) { alternatives.push_back( Alternative( tupleAssignExpr->clone(), env, Cost::zero ) ); } - void AlternativeFinder::visit( UniqueExpr *unqExpr ) { + void AlternativeFinder::Finder::postvisit( UniqueExpr *unqExpr ) { AlternativeFinder finder( indexer, env ); finder.findWithAdjustment( unqExpr->get_expr() ); @@ -1611,5 +1673,5 @@ } - void AlternativeFinder::visit( StmtExpr *stmtExpr ) { + void AlternativeFinder::Finder::postvisit( StmtExpr *stmtExpr ) { StmtExpr * newStmtExpr = stmtExpr->clone(); ResolvExpr::resolveStmtExpr( newStmtExpr, indexer ); @@ -1618,8 +1680,10 @@ } - void AlternativeFinder::visit( UntypedInitExpr *initExpr ) { + void AlternativeFinder::Finder::postvisit( UntypedInitExpr *initExpr ) { // handle each option like a cast AltList candidates; - PRINT( std::cerr << "untyped init expr: " << initExpr << std::endl; ) + PRINT( + std::cerr << "untyped init expr: " << initExpr << std::endl; + ) // O(N^2) checks of d-types with e-types for ( InitAlternative & initAlt : initExpr->get_initAlts() ) { @@ -1637,5 +1701,7 @@ AssertionSet needAssertions, haveAssertions; OpenVarSet openVars; // find things in env that don't have a "representative type" and claim those are open vars? - PRINT( std::cerr << " @ " << toType << " " << initAlt.designation << std::endl; ) + PRINT( + std::cerr << " @ " << toType << " " << initAlt.designation << std::endl; + ) // It's possible that a cast can throw away some values in a multiply-valued expression. (An example is a // cast-to-void, which casts from one value to zero.) Figure out the prefix of the subexpression results Index: src/ResolvExpr/AlternativeFinder.h =================================================================== --- src/ResolvExpr/AlternativeFinder.h (revision 78754d782a2b5ad40158459a92881261efa9c6b2) +++ src/ResolvExpr/AlternativeFinder.h (revision 13deae882b49c1c60e1d33ad6958f7f9a92fb9ee) @@ -38,5 +38,5 @@ using ExplodedArgs = std::vector< std::vector< ExplodedActual > >; - class AlternativeFinder : public Visitor { + class AlternativeFinder { public: AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env ); @@ -94,53 +94,5 @@ void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out ); private: - virtual void visit( ApplicationExpr *applicationExpr ); - virtual void visit( UntypedExpr *untypedExpr ); - virtual void visit( AddressExpr *addressExpr ); - virtual void visit( LabelAddressExpr *labelExpr ); - virtual void visit( CastExpr *castExpr ); - virtual void visit( VirtualCastExpr *castExpr ); - virtual void visit( UntypedMemberExpr *memberExpr ); - virtual void visit( MemberExpr *memberExpr ); - virtual void visit( NameExpr *variableExpr ); - virtual void visit( VariableExpr *variableExpr ); - virtual void visit( ConstantExpr *constantExpr ); - virtual void visit( SizeofExpr *sizeofExpr ); - virtual void visit( AlignofExpr *alignofExpr ); - virtual void visit( UntypedOffsetofExpr *offsetofExpr ); - virtual void visit( OffsetofExpr *offsetofExpr ); - virtual void visit( OffsetPackExpr *offsetPackExpr ); - virtual void visit( AttrExpr *attrExpr ); - virtual void visit( LogicalExpr *logicalExpr ); - virtual void visit( ConditionalExpr *conditionalExpr ); - virtual void visit( CommaExpr *commaExpr ); - virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ); - virtual void visit( ConstructorExpr * ctorExpr ); - virtual void visit( RangeExpr * rangeExpr ); - virtual void visit( UntypedTupleExpr *tupleExpr ); - virtual void visit( TupleExpr *tupleExpr ); - virtual void visit( TupleIndexExpr *tupleExpr ); - virtual void visit( TupleAssignExpr *tupleExpr ); - virtual void visit( UniqueExpr *unqExpr ); - virtual void visit( StmtExpr *stmtExpr ); - virtual void visit( UntypedInitExpr *initExpr ); - - /// Adds alternatives for anonymous members - void addAnonConversions( const Alternative & alt ); - /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member - template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ); - /// Adds alternatives for member expressions where the left side has tuple type - void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ); - /// Adds alternatives for offsetof expressions, given the base type and name of the member - template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name ); - /// Takes a final result and checks if its assertions can be satisfied - template - void validateFunctionAlternative( const Alternative &func, ArgPack& result, const std::vector& results, OutputIterator out ); - /// Finds matching alternatives for a function, given a set of arguments - template - void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const ExplodedArgs& args, OutputIterator out ); - /// Checks if assertion parameters match for a new alternative - template< typename OutputIterator > - void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ); - + struct Finder; const SymTab::Indexer &indexer; AltList alternatives;