Index: src/Common/PassVisitor.h =================================================================== --- src/Common/PassVisitor.h (revision d56e5bcda08aa6816d20a750cfe4087387b7681f) +++ src/Common/PassVisitor.h (revision e9a3b20b59d320eed25770a9bc1951960a34848a) @@ -18,5 +18,14 @@ // Templated visitor type // To use declare a PassVisitor< YOUR VISITOR TYPE > -// The visitor type should specify the previsit/postvisit for types that are desired. +// The visitor type should specify the previsit/postvisit/premutate/postmutate for types that are desired. +// Note: previsit/postvisit/premutate/postmutate must be **public** members +// +// Several additional features are available through inheritance +// | WithTypeSubstitution - provides polymorphic TypeSubstitution * env for the current expression +// | WithStmtsToAdd - provides the ability to insert statements before or after the current statement by adding new statements into +// stmtsToAddBefore or stmtsToAddAfter respectively. +// | WithShortCircuiting - provides the ability to skip visiting child nodes; set skip_children to true if pre{visit,mutate} to skip visiting children +// | WithScopes - provides the ability to save/restore data like a LIFO stack; to save, call GuardValue with the variable to save, the variable +// will automatically be restored to its previous value after the corresponding postvisit/postmutate teminates. //------------------------------------------------------------------------------------------------------------------------------------------------------------------------- template< typename pass_type > @@ -86,5 +95,4 @@ virtual void visit( ConstructorExpr * ctorExpr ) override final; virtual void visit( CompoundLiteralExpr *compLitExpr ) override final; - virtual void visit( UntypedValofExpr *valofExpr ) override final; virtual void visit( RangeExpr *rangeExpr ) override final; virtual void visit( UntypedTupleExpr *tupleExpr ) override final; @@ -172,5 +180,4 @@ virtual Expression* mutate( ConstructorExpr *ctorExpr ) override final; virtual Expression* mutate( CompoundLiteralExpr *compLitExpr ) override final; - virtual Expression* mutate( UntypedValofExpr *valofExpr ) override final; virtual Expression* mutate( RangeExpr *rangeExpr ) override final; virtual Expression* mutate( UntypedTupleExpr *tupleExpr ) override final; Index: src/Common/PassVisitor.impl.h =================================================================== --- src/Common/PassVisitor.impl.h (revision d56e5bcda08aa6816d20a750cfe4087387b7681f) +++ src/Common/PassVisitor.impl.h (revision e9a3b20b59d320eed25770a9bc1951960a34848a) @@ -6,8 +6,8 @@ call_previsit( node ); \ if( visit_children() ) { \ - reset_visit(); \ #define VISIT_END( node ) \ } \ + reset_visit(); \ call_postvisit( node ); \ @@ -17,8 +17,8 @@ call_premutate( node ); \ if( visit_children() ) { \ - reset_visit(); \ #define MUTATE_END( type, node ) \ } \ + reset_visit(); \ return call_postmutate< type * >( node ); \ @@ -159,45 +159,45 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( ObjectDecl * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( FunctionDecl * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( StructDecl * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( UnionDecl * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( EnumDecl * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TraitDecl * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TypeDecl * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TypedefDecl * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( AsmDecl * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } @@ -250,5 +250,5 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( AsmStmt * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } @@ -257,5 +257,5 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( IfStmt * node ) { - VISIT_START( node ); + VISIT_START( node ); visitExpression( node->get_condition() ); @@ -268,5 +268,5 @@ template< typename pass_type > Statement * PassVisitor< pass_type >::mutate( IfStmt * node ) { - MUTATE_START( node ); + MUTATE_START( node ); node->set_condition( mutateExpression( node->get_condition() ) ); @@ -281,5 +281,5 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( WhileStmt * node ) { - VISIT_START( node ); + VISIT_START( node ); visitExpression( node->get_condition() ); @@ -291,5 +291,5 @@ template< typename pass_type > Statement * PassVisitor< pass_type >::mutate( WhileStmt * node ) { - MUTATE_START( node ); + MUTATE_START( node ); node->set_condition( mutateExpression( node->get_condition() ) ); @@ -303,5 +303,5 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( ForStmt * node ) { - VISIT_START( node ); + VISIT_START( node ); acceptAll( node->get_initialization(), *this ); @@ -315,5 +315,5 @@ template< typename pass_type > Statement * PassVisitor< pass_type >::mutate( ForStmt * node ) { - MUTATE_START( node ); + MUTATE_START( node ); mutateAll( node->get_initialization(), *this ); @@ -329,5 +329,5 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( SwitchStmt * node ) { - VISIT_START( node ); + VISIT_START( node ); visitExpression( node->get_condition() ); @@ -339,9 +339,9 @@ template< typename pass_type > Statement * PassVisitor< pass_type >::mutate( SwitchStmt * node ) { - MUTATE_START( node ); - + MUTATE_START( node ); + node->set_condition( mutateExpression( node->get_condition() ) ); mutateStatementList( node->get_statements() ); - + MUTATE_END( Statement, node ); } @@ -351,9 +351,9 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( CaseStmt * node ) { - VISIT_START( node ); - + VISIT_START( node ); + visitExpression( node->get_condition() ); visitStatementList( node->get_statements() ); - + VISIT_END( node ); } @@ -361,9 +361,9 @@ template< typename pass_type > Statement * PassVisitor< pass_type >::mutate( CaseStmt * node ) { - MUTATE_START( node ); - + MUTATE_START( node ); + node->set_condition( mutateExpression( node->get_condition() ) ); mutateStatementList( node->get_statements() ); - + MUTATE_END( Statement, node ); } @@ -371,5 +371,5 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( BranchStmt * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } @@ -425,5 +425,5 @@ node->set_block( maybeMutate( node->get_block(), *this ) ); mutateAll( node->get_catchers(), *this ); - + MUTATE_END( Statement, node ); } @@ -444,8 +444,8 @@ Statement * PassVisitor< pass_type >::mutate( CatchStmt * node ) { MUTATE_START( node ); - + node->set_body( mutateStatement( node->get_body() ) ); node->set_decl( maybeMutate( node->get_decl(), *this ) ); - + MUTATE_END( Statement, node ); } @@ -453,25 +453,25 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( FinallyStmt * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( NullStmt * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( DeclStmt * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( ImplicitCtorDtorStmt * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( ApplicationExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } @@ -502,140 +502,135 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( NameExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( CastExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( AddressExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( LabelAddressExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( UntypedMemberExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( MemberExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( VariableExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( ConstantExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( SizeofExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( AlignofExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( UntypedOffsetofExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( OffsetofExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( OffsetPackExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( AttrExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( LogicalExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( ConditionalExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( CommaExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TypeExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( AsmExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( ImplicitCopyCtorExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( ConstructorExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( CompoundLiteralExpr * node ) { - VISIT_BODY( node ); -} - -template< typename pass_type > -void PassVisitor< pass_type >::visit( UntypedValofExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( RangeExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( UntypedTupleExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TupleExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TupleIndexExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } @@ -659,5 +654,5 @@ Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) { MUTATE_START( node ); - + // don't want statements from outer CompoundStmts to be added to this StmtExpr ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() ); @@ -672,85 +667,85 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( UniqueExpr * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( VoidType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( BasicType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( PointerType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( ArrayType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( FunctionType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( StructInstType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( UnionInstType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( EnumInstType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TraitInstType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TypeInstType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TupleType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( TypeofType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( AttrType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( VarArgsType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( ZeroType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( OneType * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } @@ -777,20 +772,20 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( ListInit * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( ConstructorInit * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( Subrange * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } template< typename pass_type > void PassVisitor< pass_type >::visit( Constant * node ) { - VISIT_BODY( node ); + VISIT_BODY( node ); } @@ -988,9 +983,4 @@ template< typename pass_type > -Expression * PassVisitor< pass_type >::mutate( UntypedValofExpr * node ) { - MUTATE_BODY( Expression, node ); -} - -template< typename pass_type > Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) { MUTATE_BODY( Expression, node ); Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision d56e5bcda08aa6816d20a750cfe4087387b7681f) +++ src/InitTweak/FixInit.cc (revision e9a3b20b59d320eed25770a9bc1951960a34848a) @@ -56,5 +56,5 @@ typedef std::unordered_map< int, int > UnqCount; - class InsertImplicitCalls { + class InsertImplicitCalls : public WithTypeSubstitution { public: /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which @@ -69,5 +69,4 @@ // collects environments for relevant nodes EnvMap & envMap; - TypeSubstitution * env; //Magically populated by the PassVisitor }; @@ -192,5 +191,5 @@ }; - class FixInit { + class FixInit : public WithStmtsToAdd { public: /// expand each object declaration to use its constructor after it is declared. @@ -200,5 +199,4 @@ std::list< Declaration * > staticDtorDecls; - std::list< Statement * > stmtsToAddAfter; // found by PassVisitor }; Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision d56e5bcda08aa6816d20a750cfe4087387b7681f) +++ src/Parser/ExpressionNode.cc (revision e9a3b20b59d320eed25770a9bc1951960a34848a) @@ -348,5 +348,5 @@ Expression *build_valexpr( StatementNode *s ) { - return new UntypedValofExpr( maybeMoveBuild< Statement >(s), nullptr ); + return new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(s) ) ); } Expression *build_typevalue( DeclarationNode *decl ) { Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision d56e5bcda08aa6816d20a750cfe4087387b7681f) +++ src/Parser/ParseNode.h (revision e9a3b20b59d320eed25770a9bc1951960a34848a) @@ -415,4 +415,6 @@ result->location = cur->location; * out++ = result; + } else { + assertf(false, "buildList unknown type"); } // if } catch( SemanticError &e ) { Index: src/Parser/StatementNode.cc =================================================================== --- src/Parser/StatementNode.cc (revision d56e5bcda08aa6816d20a750cfe4087387b7681f) +++ src/Parser/StatementNode.cc (revision e9a3b20b59d320eed25770a9bc1951960a34848a) @@ -175,6 +175,6 @@ Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt ) { - std::list< Statement * > branches; - buildMoveList< Statement, StatementNode >( catch_stmt, branches ); + std::list< CatchStmt * > branches; + buildMoveList< CatchStmt, StatementNode >( catch_stmt, branches ); CompoundStmt *tryBlock = safe_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt)); FinallyStmt *finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_stmt) ); Index: src/SymTab/Indexer.cc =================================================================== --- src/SymTab/Indexer.cc (revision d56e5bcda08aa6816d20a750cfe4087387b7681f) +++ src/SymTab/Indexer.cc (revision e9a3b20b59d320eed25770a9bc1951960a34848a) @@ -493,9 +493,4 @@ acceptNewScope( compLitExpr->get_result(), *this ); maybeAccept( compLitExpr->get_initializer(), *this ); - } - - void Indexer::visit( UntypedValofExpr *valofExpr ) { - acceptNewScope( valofExpr->get_result(), *this ); - maybeAccept( valofExpr->get_body(), *this ); } Index: src/SymTab/Indexer.h =================================================================== --- src/SymTab/Indexer.h (revision d56e5bcda08aa6816d20a750cfe4087387b7681f) +++ src/SymTab/Indexer.h (revision e9a3b20b59d320eed25770a9bc1951960a34848a) @@ -69,5 +69,4 @@ virtual void visit( ConstructorExpr * ctorExpr ); virtual void visit( CompoundLiteralExpr *compLitExpr ); - virtual void visit( UntypedValofExpr *valofExpr ); virtual void visit( RangeExpr *rangeExpr ); virtual void visit( UntypedTupleExpr *tupleExpr ); Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision d56e5bcda08aa6816d20a750cfe4087387b7681f) +++ src/SymTab/Validate.cc (revision e9a3b20b59d320eed25770a9bc1951960a34848a) @@ -115,8 +115,8 @@ /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers. - class EnumAndPointerDecayPass final : public Visitor { - typedef Visitor Parent; - virtual void visit( EnumDecl *aggregateDecl ); - virtual void visit( FunctionType *func ); + class EnumAndPointerDecay { + public: + void previsit( EnumDecl *aggregateDecl ); + void previsit( FunctionType *func ); }; @@ -126,5 +126,4 @@ public: LinkReferenceToTypes( bool doDebug, const Indexer *indexer ); - private: using Parent::visit; void visit( EnumInstType *enumInst ) final; @@ -136,5 +135,5 @@ void visit( UnionDecl *unionDecl ) final; void visit( TypeInstType *typeInst ) final; - + private: const Indexer *indexer; @@ -147,11 +146,11 @@ }; - /// Replaces array and function types in forall lists by appropriate pointer type - class Pass3 final : public Indexer { + /// Replaces array and function types in forall lists by appropriate pointer type and assigns each Object and Function declaration a unique ID. + class ForallPointerDecay final : public Indexer { typedef Indexer Parent; public: using Parent::visit; - Pass3( const Indexer *indexer ); - private: + ForallPointerDecay( const Indexer *indexer ); + virtual void visit( ObjectDecl *object ) override; virtual void visit( FunctionDecl *func ) override; @@ -160,5 +159,5 @@ }; - class ReturnChecker { + class ReturnChecker : public WithScopes { public: /// Checks that return statements return nothing if their return type is void @@ -167,10 +166,8 @@ private: void previsit( FunctionDecl * functionDecl ); - void postvisit( FunctionDecl * functionDecl ); void previsit( ReturnStmt * returnStmt ); typedef std::list< DeclarationWithType * > ReturnVals; ReturnVals returnVals; - std::stack< ReturnVals > returnValsStack; }; @@ -248,7 +245,7 @@ void validate( std::list< Declaration * > &translationUnit, bool doDebug ) { - EnumAndPointerDecayPass epc; + PassVisitor epc; LinkReferenceToTypes lrt( doDebug, 0 ); - Pass3 pass3( 0 ); + ForallPointerDecay fpd( 0 ); CompoundLiteral compoundliteral; PassVisitor genericParams; @@ -262,20 +259,20 @@ VerifyCtorDtorAssign::verify( translationUnit ); // must happen before autogen, because autogen examines existing ctor/dtors Concurrency::applyKeywords( translationUnit ); - autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecayPass + autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay Concurrency::implementMutexFuncs( translationUnit ); Concurrency::implementThreadStarter( translationUnit ); ReturnChecker::checkFunctionReturns( translationUnit ); compoundliteral.mutateDeclarationList( translationUnit ); - acceptAll( translationUnit, pass3 ); + acceptAll( translationUnit, fpd ); ArrayLength::computeLength( translationUnit ); } void validateType( Type *type, const Indexer *indexer ) { - EnumAndPointerDecayPass epc; + PassVisitor epc; LinkReferenceToTypes lrt( false, indexer ); - Pass3 pass3( indexer ); + ForallPointerDecay fpd( indexer ); type->accept( epc ); type->accept( lrt ); - type->accept( pass3 ); + type->accept( fpd ); } @@ -356,5 +353,5 @@ } - void EnumAndPointerDecayPass::visit( EnumDecl *enumDecl ) { + void EnumAndPointerDecay::previsit( EnumDecl *enumDecl ) { // Set the type of each member of the enumeration to be EnumConstant for ( std::list< Declaration * >::iterator i = enumDecl->get_members().begin(); i != enumDecl->get_members().end(); ++i ) { @@ -363,5 +360,4 @@ obj->set_type( new EnumInstType( Type::Qualifiers( Type::Const ), enumDecl->get_name() ) ); } // for - Parent::visit( enumDecl ); } @@ -370,5 +366,5 @@ void fixFunctionList( DWTList & dwts, FunctionType * func ) { // the only case in which "void" is valid is where it is the only one in the list; then it should be removed - // entirely other fix ups are handled by the FixFunction class + // entirely. other fix ups are handled by the FixFunction class typedef typename DWTList::iterator DWTIterator; DWTIterator begin( dwts.begin() ), end( dwts.end() ); @@ -389,5 +385,5 @@ for ( ; i != end; ++i ) { FixFunction fixer; - *i = (*i )->acceptMutator( fixer ); + *i = (*i)->acceptMutator( fixer ); if ( fixer.get_isVoid() ) { throw SemanticError( "invalid type void in function type ", func ); @@ -398,9 +394,8 @@ } - void EnumAndPointerDecayPass::visit( FunctionType *func ) { + void EnumAndPointerDecay::previsit( FunctionType *func ) { // Fix up parameters and return types fixFunctionList( func->get_parameters(), func ); fixFunctionList( func->get_returnVals(), func ); - Visitor::visit( func ); } @@ -549,5 +544,5 @@ } - Pass3::Pass3( const Indexer *other_indexer ) : Indexer( false ) { + ForallPointerDecay::ForallPointerDecay( const Indexer *other_indexer ) : Indexer( false ) { if ( other_indexer ) { indexer = other_indexer; @@ -587,5 +582,5 @@ } - void Pass3::visit( ObjectDecl *object ) { + void ForallPointerDecay::visit( ObjectDecl *object ) { forallFixer( object->get_type() ); if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) { @@ -596,5 +591,5 @@ } - void Pass3::visit( FunctionDecl *func ) { + void ForallPointerDecay::visit( FunctionDecl *func ) { forallFixer( func->get_type() ); Parent::visit( func ); @@ -608,10 +603,6 @@ void ReturnChecker::previsit( FunctionDecl * functionDecl ) { - returnValsStack.push( returnVals ); + GuardValue( returnVals ); returnVals = functionDecl->get_functionType()->get_returnVals(); - } - void ReturnChecker::postvisit( __attribute__((unused)) FunctionDecl * functionDecl ) { - returnVals = returnValsStack.top(); - returnValsStack.pop(); } Index: src/SynTree/BaseSyntaxNode.h =================================================================== --- src/SynTree/BaseSyntaxNode.h (revision d56e5bcda08aa6816d20a750cfe4087387b7681f) +++ src/SynTree/BaseSyntaxNode.h (revision e9a3b20b59d320eed25770a9bc1951960a34848a) @@ -24,5 +24,7 @@ CodeLocation location; - virtual void accept( Visitor & v ) = 0; // temporary -- needs to be here so that BaseSyntaxNode is polymorphic and can be dynamic_cast + virtual ~BaseSyntaxNode() {} + + virtual void accept( Visitor & v ) = 0; }; Index: src/SynTree/Expression.cc =================================================================== --- src/SynTree/Expression.cc (revision d56e5bcda08aa6816d20a750cfe4087387b7681f) +++ src/SynTree/Expression.cc (revision e9a3b20b59d320eed25770a9bc1951960a34848a) @@ -288,6 +288,4 @@ } -// CastExpr *CastExpr::clone() const { return 0; } - void CastExpr::print( std::ostream &os, int indent ) const { os << "Cast of:" << std::endl << std::string( indent+2, ' ' ); @@ -355,5 +353,4 @@ } -//// is this right? It's cloning the member, but the member is a declaration so probably shouldn't be cloned... MemberExpr::MemberExpr( const MemberExpr &other ) : Expression( other ), member( other.member ), aggregate( maybeClone( other.aggregate ) ) { @@ -361,5 +358,5 @@ MemberExpr::~MemberExpr() { - // delete member; + // don't delete the member declaration, since it points somewhere else in the tree delete aggregate; } @@ -591,14 +588,4 @@ } -UntypedValofExpr::UntypedValofExpr( const UntypedValofExpr & other ) : Expression( other ), body ( maybeClone( other.body ) ) {} - -UntypedValofExpr::~UntypedValofExpr() { delete body; } - -void UntypedValofExpr::print( std::ostream &os, int indent ) const { - os << std::string( indent, ' ' ) << "Valof Expression: " << std::endl; - if ( get_body() != 0 ) - get_body()->print( os, indent + 2 ); -} - RangeExpr::RangeExpr( Expression *low, Expression *high ) : low( low ), high( high ) {} RangeExpr::RangeExpr( const RangeExpr &other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {} Index: src/SynTree/Expression.h =================================================================== --- src/SynTree/Expression.h (revision d56e5bcda08aa6816d20a750cfe4087387b7681f) +++ src/SynTree/Expression.h (revision e9a3b20b59d320eed25770a9bc1951960a34848a) @@ -226,5 +226,6 @@ }; -/// MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer +/// MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer. +/// Does not take ownership of member. class MemberExpr : public Expression { public: @@ -247,5 +248,6 @@ }; -/// VariableExpr represents an expression that simply refers to the value of a named variable +/// VariableExpr represents an expression that simply refers to the value of a named variable. +/// Does not take ownership of var. class VariableExpr : public Expression { public: @@ -598,22 +600,4 @@ }; -/// ValofExpr represents a GCC 'lambda expression' -class UntypedValofExpr : public Expression { - public: - UntypedValofExpr( Statement *_body, Expression *_aname = nullptr ) : Expression( _aname ), body ( _body ) {} - UntypedValofExpr( const UntypedValofExpr & other ); - virtual ~UntypedValofExpr(); - - Expression * get_value(); - Statement * get_body() const { return body; } - - virtual UntypedValofExpr * clone() const { return new UntypedValofExpr( * this ); } - virtual void accept( Visitor & v ) { v.visit( this ); } - virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); } - virtual void print( std::ostream & os, int indent = 0 ) const; - private: - Statement * body; -}; - /// RangeExpr represents a range e.g. '3 ... 5' or '1~10' class RangeExpr : public Expression { Index: src/SynTree/Mutator.cc =================================================================== --- src/SynTree/Mutator.cc (revision d56e5bcda08aa6816d20a750cfe4087387b7681f) +++ src/SynTree/Mutator.cc (revision e9a3b20b59d320eed25770a9bc1951960a34848a) @@ -380,10 +380,4 @@ } -Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) { - valofExpr->set_env( maybeMutate( valofExpr->get_env(), *this ) ); - valofExpr->set_result( maybeMutate( valofExpr->get_result(), *this ) ); - return valofExpr; -} - Expression *Mutator::mutate( RangeExpr *rangeExpr ) { rangeExpr->set_env( maybeMutate( rangeExpr->get_env(), *this ) ); Index: src/SynTree/Mutator.h =================================================================== --- src/SynTree/Mutator.h (revision d56e5bcda08aa6816d20a750cfe4087387b7681f) +++ src/SynTree/Mutator.h (revision e9a3b20b59d320eed25770a9bc1951960a34848a) @@ -78,5 +78,4 @@ virtual Expression* mutate( ConstructorExpr *ctorExpr ); virtual Expression* mutate( CompoundLiteralExpr *compLitExpr ); - virtual Expression* mutate( UntypedValofExpr *valofExpr ); virtual Expression* mutate( RangeExpr *rangeExpr ); virtual Expression* mutate( UntypedTupleExpr *tupleExpr ); Index: src/SynTree/ObjectDecl.cc =================================================================== --- src/SynTree/ObjectDecl.cc (revision d56e5bcda08aa6816d20a750cfe4087387b7681f) +++ src/SynTree/ObjectDecl.cc (revision e9a3b20b59d320eed25770a9bc1951960a34848a) @@ -56,7 +56,7 @@ if ( init ) { - os << " with initializer "; - init->print( os, indent ); - os << std::endl << std::string(indent, ' '); + os << " with initializer " << std::endl; + init->print( os, indent+2 ); + os << std::endl << std::string(indent+2, ' '); os << "maybeConstructed? " << init->get_maybeConstructed(); } // if Index: src/SynTree/Statement.cc =================================================================== --- src/SynTree/Statement.cc (revision d56e5bcda08aa6816d20a750cfe4087387b7681f) +++ src/SynTree/Statement.cc (revision e9a3b20b59d320eed25770a9bc1951960a34848a) @@ -313,5 +313,5 @@ } -TryStmt::TryStmt( std::list