Index: src/Common/PassVisitor.impl.h =================================================================== --- src/Common/PassVisitor.impl.h (revision c0714bfd6119abb84c6c2aa4881ff5f14758638c) +++ src/Common/PassVisitor.impl.h (revision 33a25f904db2c5a826a55cdb66cfd7d4cc979de3) @@ -293,4 +293,22 @@ //------------------------------------------------------------------------------------------------------------------------------------------------------------------------ +// A NOTE ON THE ORDER OF TRAVERSAL +// +// Types and typedefs have their base types visited before they are added to the type table. This is ok, since there is +// no such thing as a recursive type or typedef. +// +// typedef struct { T *x; } T; // never allowed +// +// for structs/unions, it is possible to have recursion, so the decl should be added as if it's incomplete to begin, the +// members are traversed, and then the complete type should be added (assuming the type is completed by this particular +// declaration). +// +// struct T { struct T *x; }; // allowed +// +// It is important to add the complete type to the symbol table *after* the members/base has been traversed, since that +// traversal may modify the definition of the type and these modifications should be visible when the symbol table is +// queried later in this pass. +// +// TODO: figure out whether recursive contexts are sensible/possible/reasonable. //-------------------------------------------------------------------------- @@ -450,5 +468,5 @@ indexerAddEnum( node ); - // unlike structs, contexts, and unions, enums inject their members into the global scope + // unlike structs, traits, and unions, enums inject their members into the global scope maybeAccept( node->parameters, *this ); maybeAccept( node->members , *this ); @@ -514,4 +532,7 @@ } + // see A NOTE ON THE ORDER OF TRAVERSAL, above + // note that assertions come after the type is added to the symtab, since they are not part of the type proper + // and may depend on the type itself indexerAddType( node ); @@ -533,4 +554,7 @@ } + // see A NOTE ON THE ORDER OF TRAVERSAL, above + // note that assertions come after the type is added to the symtab, since they are not part of the type proper + // and may depend on the type itself indexerAddType( node ); @@ -659,9 +683,12 @@ void PassVisitor< pass_type >::visit( IfStmt * node ) { VISIT_START( node ); - - visitExpression( node->condition ); - node->thenPart = visitStatement( node->thenPart ); - node->elsePart = visitStatement( node->elsePart ); - + { + // if statements introduce a level of scope (for the initialization) + auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); + acceptAll( node->get_initialization(), *this ); + visitExpression( node->condition ); + node->thenPart = visitStatement( node->thenPart ); + node->elsePart = visitStatement( node->elsePart ); + } VISIT_END( node ); } @@ -671,5 +698,7 @@ MUTATE_START( node ); { - auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); + // if statements introduce a level of scope (for the initialization) + auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); + maybeMutateRef( node->get_initialization(), *this ); node->condition = mutateExpression( node->condition ); node->thenPart = mutateStatement ( node->thenPart ); @@ -707,4 +736,5 @@ VISIT_START( node ); { + // for statements introduce a level of scope (for the initialization) auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); maybeAccept( node->initialization, *this ); @@ -720,4 +750,5 @@ MUTATE_START( node ); { + // for statements introduce a level of scope (for the initialization) auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); maybeMutateRef( node->initialization, *this ); @@ -848,4 +879,5 @@ VISIT_START( node ); { + // catch statements introduce a level of scope (for the caught exception) auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); maybeAccept( node->decl, *this ); @@ -860,4 +892,5 @@ MUTATE_START( node ); { + // catch statements introduce a level of scope (for the caught exception) auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); maybeMutateRef( node->decl, *this ); Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision c0714bfd6119abb84c6c2aa4881ff5f14758638c) +++ src/InitTweak/FixInit.cc (revision 33a25f904db2c5a826a55cdb66cfd7d4cc979de3) @@ -1155,5 +1155,5 @@ // in generated code. If this changes, add mutate methods for entities with // scope and call {enter,leave}Scope explicitly. - objectDecl->accept( indexer ); + indexer.addId( objectDecl ); return objectDecl; } Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision c0714bfd6119abb84c6c2aa4881ff5f14758638c) +++ src/ResolvExpr/AlternativeFinder.cc (revision 33a25f904db2c5a826a55cdb66cfd7d4cc979de3) @@ -523,5 +523,5 @@ for ( AssertionSet::iterator i = assertSet.begin(); i != assertSet.end(); ++i ) { if ( i->second.isUsed ) { - i->first->accept( indexer ); + indexer.addId( i->first ); } } Index: src/SymTab/Indexer.cc =================================================================== --- src/SymTab/Indexer.cc (revision c0714bfd6119abb84c6c2aa4881ff5f14758638c) +++ src/SymTab/Indexer.cc (revision 33a25f904db2c5a826a55cdb66cfd7d4cc979de3) @@ -230,349 +230,4 @@ return *this; - } - - void Indexer::visit( ObjectDecl *objectDecl ) { - enterScope(); - maybeAccept( objectDecl->get_type(), *this ); - leaveScope(); - maybeAccept( objectDecl->get_init(), *this ); - maybeAccept( objectDecl->get_bitfieldWidth(), *this ); - if ( objectDecl->get_name() != "" ) { - debugPrint( "Adding object " << objectDecl->get_name() << std::endl ); - addId( objectDecl ); - } // if - } - - void Indexer::visit( FunctionDecl *functionDecl ) { - if ( functionDecl->get_name() == "" ) return; - debugPrint( "Adding function " << functionDecl->get_name() << std::endl ); - addId( functionDecl ); - enterScope(); - maybeAccept( functionDecl->get_functionType(), *this ); - maybeAccept( functionDecl->get_statements(), *this ); - leaveScope(); - } - - -// A NOTE ON THE ORDER OF TRAVERSAL -// -// Types and typedefs have their base types visited before they are added to the type table. This is ok, since there is -// no such thing as a recursive type or typedef. -// -// typedef struct { T *x; } T; // never allowed -// -// for structs/unions, it is possible to have recursion, so the decl should be added as if it's incomplete to begin, the -// members are traversed, and then the complete type should be added (assuming the type is completed by this particular -// declaration). -// -// struct T { struct T *x; }; // allowed -// -// It is important to add the complete type to the symbol table *after* the members/base has been traversed, since that -// traversal may modify the definition of the type and these modifications should be visible when the symbol table is -// queried later in this pass. -// -// TODO: figure out whether recursive contexts are sensible/possible/reasonable. - - - void Indexer::visit( TypeDecl *typeDecl ) { - // see A NOTE ON THE ORDER OF TRAVERSAL, above - // note that assertions come after the type is added to the symtab, since they are not part of the type proper - // and may depend on the type itself - enterScope(); - acceptAll( typeDecl->get_parameters(), *this ); - maybeAccept( typeDecl->get_base(), *this ); - leaveScope(); - debugPrint( "Adding type " << typeDecl->get_name() << std::endl ); - addType( typeDecl ); - acceptAll( typeDecl->get_assertions(), *this ); - acceptNewScope( typeDecl->get_init(), *this ); - } - - void Indexer::visit( TypedefDecl *typeDecl ) { - enterScope(); - acceptAll( typeDecl->get_parameters(), *this ); - maybeAccept( typeDecl->get_base(), *this ); - leaveScope(); - debugPrint( "Adding typedef " << typeDecl->get_name() << std::endl ); - addType( typeDecl ); - } - - void Indexer::visit( StructDecl *aggregateDecl ) { - // make up a forward declaration and add it before processing the members - // needs to be on the heap because addStruct saves the pointer - StructDecl &fwdDecl = *new StructDecl( aggregateDecl->get_name() ); - cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() ); - debugPrint( "Adding fwd decl for struct " << fwdDecl.get_name() << std::endl ); - addStruct( &fwdDecl ); - - enterScope(); - acceptAll( aggregateDecl->get_parameters(), *this ); - acceptAll( aggregateDecl->get_members(), *this ); - leaveScope(); - - debugPrint( "Adding struct " << aggregateDecl->get_name() << std::endl ); - // this addition replaces the forward declaration - addStruct( aggregateDecl ); - } - - void Indexer::visit( UnionDecl *aggregateDecl ) { - // make up a forward declaration and add it before processing the members - UnionDecl fwdDecl( aggregateDecl->get_name() ); - cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() ); - debugPrint( "Adding fwd decl for union " << fwdDecl.get_name() << std::endl ); - addUnion( &fwdDecl ); - - enterScope(); - acceptAll( aggregateDecl->get_parameters(), *this ); - acceptAll( aggregateDecl->get_members(), *this ); - leaveScope(); - - debugPrint( "Adding union " << aggregateDecl->get_name() << std::endl ); - addUnion( aggregateDecl ); - } - - void Indexer::visit( EnumDecl *aggregateDecl ) { - debugPrint( "Adding enum " << aggregateDecl->get_name() << std::endl ); - addEnum( aggregateDecl ); - // unlike structs, contexts, and unions, enums inject their members into the global scope - acceptAll( aggregateDecl->get_members(), *this ); - } - - void Indexer::visit( TraitDecl *aggregateDecl ) { - enterScope(); - acceptAll( aggregateDecl->get_parameters(), *this ); - acceptAll( aggregateDecl->get_members(), *this ); - leaveScope(); - - debugPrint( "Adding trait " << aggregateDecl->get_name() << std::endl ); - addTrait( aggregateDecl ); - } - - void Indexer::visit( CompoundStmt *compoundStmt ) { - enterScope(); - acceptAll( compoundStmt->get_kids(), *this ); - leaveScope(); - } - - void Indexer::visit( IfStmt *ifStmt ) { - // for statements introduce a level of scope - enterScope(); - Visitor::visit( ifStmt ); - leaveScope(); - } - - void Indexer::visit( ForStmt *forStmt ) { - // for statements introduce a level of scope - enterScope(); - Visitor::visit( forStmt ); - leaveScope(); - } - - void Indexer::visit( CatchStmt *catchStmt ) { - // catch statements introduce a level of scope (for the caught exception) - enterScope(); - Visitor::visit( catchStmt ); - leaveScope(); - } - - void Indexer::visit( ApplicationExpr *applicationExpr ) { - acceptNewScope( applicationExpr->get_result(), *this ); - maybeAccept( applicationExpr->get_function(), *this ); - acceptAll( applicationExpr->get_args(), *this ); - } - - void Indexer::visit( UntypedExpr *untypedExpr ) { - acceptNewScope( untypedExpr->get_result(), *this ); - acceptAll( untypedExpr->get_args(), *this ); - } - - void Indexer::visit( NameExpr *nameExpr ) { - acceptNewScope( nameExpr->get_result(), *this ); - } - - void Indexer::visit( AddressExpr *addressExpr ) { - acceptNewScope( addressExpr->get_result(), *this ); - maybeAccept( addressExpr->get_arg(), *this ); - } - - void Indexer::visit( LabelAddressExpr *labAddressExpr ) { - acceptNewScope( labAddressExpr->get_result(), *this ); - } - - void Indexer::visit( CastExpr *castExpr ) { - acceptNewScope( castExpr->get_result(), *this ); - maybeAccept( castExpr->get_arg(), *this ); - } - - void Indexer::visit( UntypedMemberExpr *memberExpr ) { - acceptNewScope( memberExpr->get_result(), *this ); - maybeAccept( memberExpr->get_aggregate(), *this ); - } - - void Indexer::visit( MemberExpr *memberExpr ) { - acceptNewScope( memberExpr->get_result(), *this ); - maybeAccept( memberExpr->get_aggregate(), *this ); - } - - void Indexer::visit( VariableExpr *variableExpr ) { - acceptNewScope( variableExpr->get_result(), *this ); - } - - void Indexer::visit( ConstantExpr *constantExpr ) { - acceptNewScope( constantExpr->get_result(), *this ); - maybeAccept( constantExpr->get_constant(), *this ); - } - - void Indexer::visit( SizeofExpr *sizeofExpr ) { - acceptNewScope( sizeofExpr->get_result(), *this ); - if ( sizeofExpr->get_isType() ) { - maybeAccept( sizeofExpr->get_type(), *this ); - } else { - maybeAccept( sizeofExpr->get_expr(), *this ); - } - } - - void Indexer::visit( AlignofExpr *alignofExpr ) { - acceptNewScope( alignofExpr->get_result(), *this ); - if ( alignofExpr->get_isType() ) { - maybeAccept( alignofExpr->get_type(), *this ); - } else { - maybeAccept( alignofExpr->get_expr(), *this ); - } - } - - void Indexer::visit( UntypedOffsetofExpr *offsetofExpr ) { - acceptNewScope( offsetofExpr->get_result(), *this ); - maybeAccept( offsetofExpr->get_type(), *this ); - } - - void Indexer::visit( OffsetofExpr *offsetofExpr ) { - acceptNewScope( offsetofExpr->get_result(), *this ); - maybeAccept( offsetofExpr->get_type(), *this ); - maybeAccept( offsetofExpr->get_member(), *this ); - } - - void Indexer::visit( OffsetPackExpr *offsetPackExpr ) { - acceptNewScope( offsetPackExpr->get_result(), *this ); - maybeAccept( offsetPackExpr->get_type(), *this ); - } - - void Indexer::visit( AttrExpr *attrExpr ) { - acceptNewScope( attrExpr->get_result(), *this ); - if ( attrExpr->get_isType() ) { - maybeAccept( attrExpr->get_type(), *this ); - } else { - maybeAccept( attrExpr->get_expr(), *this ); - } - } - - void Indexer::visit( LogicalExpr *logicalExpr ) { - acceptNewScope( logicalExpr->get_result(), *this ); - maybeAccept( logicalExpr->get_arg1(), *this ); - maybeAccept( logicalExpr->get_arg2(), *this ); - } - - void Indexer::visit( ConditionalExpr *conditionalExpr ) { - acceptNewScope( conditionalExpr->get_result(), *this ); - maybeAccept( conditionalExpr->get_arg1(), *this ); - maybeAccept( conditionalExpr->get_arg2(), *this ); - maybeAccept( conditionalExpr->get_arg3(), *this ); - } - - void Indexer::visit( CommaExpr *commaExpr ) { - acceptNewScope( commaExpr->get_result(), *this ); - maybeAccept( commaExpr->get_arg1(), *this ); - maybeAccept( commaExpr->get_arg2(), *this ); - } - - void Indexer::visit( TypeExpr *typeExpr ) { - acceptNewScope( typeExpr->get_result(), *this ); - maybeAccept( typeExpr->get_type(), *this ); - } - - void Indexer::visit( AsmExpr *asmExpr ) { - maybeAccept( asmExpr->get_inout(), *this ); - maybeAccept( asmExpr->get_constraint(), *this ); - maybeAccept( asmExpr->get_operand(), *this ); - } - - void Indexer::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) { - acceptNewScope( impCpCtorExpr->get_result(), *this ); - maybeAccept( impCpCtorExpr->get_callExpr(), *this ); - acceptAll( impCpCtorExpr->get_tempDecls(), *this ); - acceptAll( impCpCtorExpr->get_returnDecls(), *this ); - acceptAll( impCpCtorExpr->get_dtors(), *this ); - } - - void Indexer::visit( ConstructorExpr * ctorExpr ) { - acceptNewScope( ctorExpr->get_result(), *this ); - maybeAccept( ctorExpr->get_callExpr(), *this ); - } - - void Indexer::visit( CompoundLiteralExpr *compLitExpr ) { - acceptNewScope( compLitExpr->get_result(), *this ); - maybeAccept( compLitExpr->get_initializer(), *this ); - } - - void Indexer::visit( RangeExpr *rangeExpr ) { - maybeAccept( rangeExpr->get_low(), *this ); - maybeAccept( rangeExpr->get_high(), *this ); - } - - void Indexer::visit( UntypedTupleExpr *tupleExpr ) { - acceptNewScope( tupleExpr->get_result(), *this ); - acceptAll( tupleExpr->get_exprs(), *this ); - } - - void Indexer::visit( TupleExpr *tupleExpr ) { - acceptNewScope( tupleExpr->get_result(), *this ); - acceptAll( tupleExpr->get_exprs(), *this ); - } - - void Indexer::visit( TupleIndexExpr *tupleExpr ) { - acceptNewScope( tupleExpr->get_result(), *this ); - maybeAccept( tupleExpr->get_tuple(), *this ); - } - - void Indexer::visit( TupleAssignExpr *tupleExpr ) { - acceptNewScope( tupleExpr->get_result(), *this ); - maybeAccept( tupleExpr->get_stmtExpr(), *this ); - } - - void Indexer::visit( StmtExpr *stmtExpr ) { - acceptNewScope( stmtExpr->get_result(), *this ); - maybeAccept( stmtExpr->get_statements(), *this ); - acceptAll( stmtExpr->get_returnDecls(), *this ); - acceptAll( stmtExpr->get_dtors(), *this ); - } - - void Indexer::visit( UniqueExpr *uniqueExpr ) { - acceptNewScope( uniqueExpr->get_result(), *this ); - maybeAccept( uniqueExpr->get_expr(), *this ); - } - - - void Indexer::visit( TraitInstType *traitInst ) { - acceptAll( traitInst->get_parameters(), *this ); - } - - void Indexer::visit( StructInstType *structInst ) { - if ( ! lookupStruct( structInst->get_name() ) ) { - debugPrint( "Adding struct " << structInst->get_name() << " from implicit forward declaration" << std::endl ); - addStruct( structInst->get_name() ); - } - enterScope(); - acceptAll( structInst->get_parameters(), *this ); - leaveScope(); - } - - void Indexer::visit( UnionInstType *unionInst ) { - if ( ! lookupUnion( unionInst->get_name() ) ) { - debugPrint( "Adding union " << unionInst->get_name() << " from implicit forward declaration" << std::endl ); - addUnion( unionInst->get_name() ); - } - enterScope(); - acceptAll( unionInst->get_parameters(), *this ); - leaveScope(); } @@ -762,4 +417,5 @@ void Indexer::addId( DeclarationWithType *decl ) { + debugPrint( "Adding Id " << decl->name << std::endl ); makeWritable(); @@ -811,4 +467,5 @@ void Indexer::addType( NamedTypeDecl *decl ) { + debugPrint( "Adding type " << decl->name << std::endl ); makeWritable(); @@ -838,8 +495,10 @@ void Indexer::addStruct( const std::string &id ) { + debugPrint( "Adding fwd decl for struct " << id << std::endl ); addStruct( new StructDecl( id ) ); } void Indexer::addStruct( StructDecl *decl ) { + debugPrint( "Adding struct " << decl->name << std::endl ); makeWritable(); @@ -860,4 +519,5 @@ void Indexer::addEnum( EnumDecl *decl ) { + debugPrint( "Adding enum " << decl->name << std::endl ); makeWritable(); @@ -878,8 +538,10 @@ void Indexer::addUnion( const std::string &id ) { + debugPrint( "Adding fwd decl for union " << id << std::endl ); addUnion( new UnionDecl( id ) ); } void Indexer::addUnion( UnionDecl *decl ) { + debugPrint( "Adding union " << decl->name << std::endl ); makeWritable(); @@ -900,4 +562,5 @@ void Indexer::addTrait( TraitDecl *decl ) { + debugPrint( "Adding trait " << decl->name << std::endl ); makeWritable(); Index: src/SymTab/Indexer.h =================================================================== --- src/SymTab/Indexer.h (revision c0714bfd6119abb84c6c2aa4881ff5f14758638c) +++ src/SymTab/Indexer.h (revision 33a25f904db2c5a826a55cdb66cfd7d4cc979de3) @@ -24,5 +24,5 @@ namespace SymTab { - class Indexer : public Visitor { + class Indexer { public: explicit Indexer( bool useDebug = false ); @@ -33,55 +33,4 @@ Indexer& operator= ( const Indexer &that ); Indexer& operator= ( Indexer &&that ); - - using Visitor::visit; - virtual void visit( ObjectDecl *objectDecl ); - virtual void visit( FunctionDecl *functionDecl ); - virtual void visit( TypeDecl *typeDecl ); - virtual void visit( TypedefDecl *typeDecl ); - virtual void visit( StructDecl *aggregateDecl ); - virtual void visit( UnionDecl *aggregateDecl ); - virtual void visit( EnumDecl *aggregateDecl ); - virtual void visit( TraitDecl *aggregateDecl ); - - virtual void visit( CompoundStmt *compoundStmt ); - virtual void visit( IfStmt *ifStmt ); - virtual void visit( ForStmt *forStmt ); - virtual void visit( CatchStmt *catchStmt ); - - virtual void visit( ApplicationExpr *applicationExpr ); - virtual void visit( UntypedExpr *untypedExpr ); - virtual void visit( NameExpr *nameExpr ); - virtual void visit( CastExpr *castExpr ); - virtual void visit( AddressExpr *addressExpr ); - virtual void visit( LabelAddressExpr *labAddressExpr ); - virtual void visit( UntypedMemberExpr *memberExpr ); - virtual void visit( MemberExpr *memberExpr ); - 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( TypeExpr *typeExpr ); - virtual void visit( AsmExpr *asmExpr ); - virtual void visit( ImplicitCopyCtorExpr *impCpCtorExpr ); - virtual void visit( ConstructorExpr * ctorExpr ); - virtual void visit( CompoundLiteralExpr *compLitExpr ); - 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( StmtExpr * stmtExpr ); - virtual void visit( UniqueExpr * uniqueExpr ); - - virtual void visit( TraitInstType *contextInst ); - virtual void visit( StructInstType *contextInst ); - virtual void visit( UnionInstType *contextInst ); // when using an indexer manually (e.g., within a mutator traversal), it is necessary to tell the indexer