Index: src/InitTweak/FixGlobalInit.cc =================================================================== --- src/InitTweak/FixGlobalInit.cc (revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9) +++ src/InitTweak/FixGlobalInit.cc (revision aad677d7c2bd4b3b3e41d177e27db0dfdaba484f) @@ -27,5 +27,5 @@ namespace InitTweak { - class GlobalFixer_new : public ast::WithShortCircuiting { + class GlobalFixer : public ast::WithShortCircuiting { public: void previsit (const ast::ObjectDecl *); @@ -42,5 +42,5 @@ void fixGlobalInit(ast::TranslationUnit & translationUnit, bool inLibrary) { - ast::Pass fixer; + ast::Pass fixer; accept_all(translationUnit, fixer); @@ -73,5 +73,5 @@ } - void GlobalFixer_new::previsit(const ast::ObjectDecl * objDecl) { + void GlobalFixer::previsit(const ast::ObjectDecl * objDecl) { auto mutDecl = mutate(objDecl); assertf(mutDecl == objDecl, "Global object decl must be unique"); Index: src/InitTweak/FixInitNew.cpp =================================================================== --- src/InitTweak/FixInitNew.cpp (revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9) +++ src/InitTweak/FixInitNew.cpp (revision aad677d7c2bd4b3b3e41d177e27db0dfdaba484f) @@ -917,5 +917,5 @@ // static variables with the same name in different functions. // Note: it isn't sufficient to modify only the mangleName, because - // then subsequent Indexer passes can choke on seeing the object's name + // then subsequent SymbolTable passes can choke on seeing the object's name // if another object has the same name and type. An unfortunate side-effect // of renaming the object is that subsequent NameExprs may fail to resolve, @@ -1169,5 +1169,5 @@ arg2 = new ast::MemberExpr(funcDecl->location, field, new ast::VariableExpr(funcDecl->location, function->params.back() ) ); } - InitExpander_new srcParam( arg2 ); + InitExpander srcParam( arg2 ); // cast away reference type and construct field. ast::Expr * thisExpr = new ast::CastExpr(funcDecl->location, new ast::VariableExpr(funcDecl->location, thisParam ), thisParam->get_type()->stripReferences()); Index: src/InitTweak/GenInit.cc =================================================================== --- src/InitTweak/GenInit.cc (revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9) +++ src/InitTweak/GenInit.cc (revision aad677d7c2bd4b3b3e41d177e27db0dfdaba484f) @@ -46,11 +46,9 @@ namespace { -# warning Remove the _New suffix after the conversion is complete. - // Outer pass finds declarations, for their type could wrap a type that needs hoisting - struct HoistArrayDimension_NoResolve_New final : + struct HoistArrayDimension_NoResolve final : public ast::WithDeclsToAdd<>, public ast::WithShortCircuiting, public ast::WithGuards, public ast::WithConstTranslationUnit, - public ast::WithVisitorRef, + public ast::WithVisitorRef, public ast::WithSymbolTableX { @@ -59,6 +57,6 @@ public ast::WithShortCircuiting, public ast::WithGuards { - HoistArrayDimension_NoResolve_New * outer; - HoistDimsFromTypes( HoistArrayDimension_NoResolve_New * outer ) : outer(outer) {} + HoistArrayDimension_NoResolve * outer; + HoistDimsFromTypes( HoistArrayDimension_NoResolve * outer ) : outer(outer) {} // Only intended for visiting through types. @@ -211,5 +209,5 @@ - struct ReturnFixer_New final : + struct ReturnFixer final : public ast::WithStmtsToAdd<>, ast::WithGuards, ast::WithShortCircuiting { void previsit( const ast::FunctionDecl * decl ); @@ -219,10 +217,10 @@ }; - void ReturnFixer_New::previsit( const ast::FunctionDecl * decl ) { + void ReturnFixer::previsit( const ast::FunctionDecl * decl ) { if (decl->linkage == ast::Linkage::Intrinsic) visit_children = false; GuardValue( funcDecl ) = decl; } - const ast::ReturnStmt * ReturnFixer_New::previsit( + const ast::ReturnStmt * ReturnFixer::previsit( const ast::ReturnStmt * stmt ) { auto & returns = funcDecl->returns; @@ -265,13 +263,13 @@ void genInit( ast::TranslationUnit & transUnit ) { - ast::Pass::run( transUnit ); - ast::Pass::run( transUnit ); + ast::Pass::run( transUnit ); + ast::Pass::run( transUnit ); } void fixReturnStatements( ast::TranslationUnit & transUnit ) { - ast::Pass::run( transUnit ); - } - - bool ManagedTypes_new::isManaged( const ast::Type * type ) const { + ast::Pass::run( transUnit ); + } + + bool ManagedTypes::isManaged( const ast::Type * type ) const { // references are never constructed if ( dynamic_cast< const ast::ReferenceType * >( type ) ) return false; @@ -292,5 +290,5 @@ } - bool ManagedTypes_new::isManaged( const ast::ObjectDecl * objDecl ) const { + bool ManagedTypes::isManaged( const ast::ObjectDecl * objDecl ) const { const ast::Type * type = objDecl->type; while ( auto at = dynamic_cast< const ast::ArrayType * >( type ) ) { @@ -302,5 +300,5 @@ } - void ManagedTypes_new::handleDWT( const ast::DeclWithType * dwt ) { + void ManagedTypes::handleDWT( const ast::DeclWithType * dwt ) { // if this function is a user-defined constructor or destructor, mark down the type as "managed" if ( ! dwt->linkage.is_overrideable && CodeGen::isCtorDtor( dwt->name ) ) { @@ -313,5 +311,5 @@ } - void ManagedTypes_new::handleStruct( const ast::StructDecl * aggregateDecl ) { + void ManagedTypes::handleStruct( const ast::StructDecl * aggregateDecl ) { // don't construct members, but need to take note if there is a managed member, // because that means that this type is also managed @@ -329,10 +327,10 @@ } - void ManagedTypes_new::beginScope() { managedTypes.beginScope(); } - void ManagedTypes_new::endScope() { managedTypes.endScope(); } + void ManagedTypes::beginScope() { managedTypes.beginScope(); } + void ManagedTypes::endScope() { managedTypes.endScope(); } ast::ptr genCtorDtor (const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * objDecl, const ast::Expr * arg) { assertf(objDecl, "genCtorDtor passed null objDecl"); - InitExpander_new srcParam(arg); + InitExpander srcParam(arg); return SymTab::genImplicitCall(srcParam, new ast::VariableExpr(loc, objDecl), loc, fname, objDecl); } @@ -341,5 +339,5 @@ // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor for each // constructable object - InitExpander_new srcParam{ objDecl->init }, nullParam{ (const ast::Init *)nullptr }; + InitExpander srcParam{ objDecl->init }, nullParam{ (const ast::Init *)nullptr }; ast::ptr< ast::Expr > dstParam = new ast::VariableExpr(loc, objDecl); Index: src/InitTweak/GenInit.h =================================================================== --- src/InitTweak/GenInit.h (revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9) +++ src/InitTweak/GenInit.h (revision aad677d7c2bd4b3b3e41d177e27db0dfdaba484f) @@ -37,5 +37,5 @@ ast::ConstructorInit * genCtorInit( const CodeLocation & loc, const ast::ObjectDecl * objDecl ); - class ManagedTypes_new { + class ManagedTypes final { public: bool isManaged( const ast::ObjectDecl * objDecl ) const ; // determine if object is managed Index: src/InitTweak/InitTweak.cc =================================================================== --- src/InitTweak/InitTweak.cc (revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9) +++ src/InitTweak/InitTweak.cc (revision aad677d7c2bd4b3b3e41d177e27db0dfdaba484f) @@ -39,5 +39,5 @@ namespace InitTweak { namespace { - struct HasDesignations_new : public ast::WithShortCircuiting { + struct HasDesignations : public ast::WithShortCircuiting { bool result = false; @@ -57,9 +57,9 @@ }; - struct InitDepthChecker_new { + struct InitDepthChecker { bool result = true; const ast::Type * type; int curDepth = 0, maxDepth = 0; - InitDepthChecker_new( const ast::Type * type ) : type( type ) { + InitDepthChecker( const ast::Type * type ) : type( type ) { const ast::Type * t = type; while ( auto at = dynamic_cast< const ast::ArrayType * >( t ) ) { @@ -78,5 +78,5 @@ }; - struct InitFlattener_new : public ast::WithShortCircuiting { + struct InitFlattener : public ast::WithShortCircuiting { std::vector< ast::ptr< ast::Expr > > argList; @@ -90,5 +90,5 @@ bool isDesignated( const ast::Init * init ) { - ast::Pass finder; + ast::Pass finder; maybe_accept( init, finder ); return finder.core.result; @@ -96,5 +96,5 @@ bool checkInitDepth( const ast::ObjectDecl * objDecl ) { - ast::Pass checker( objDecl->type ); + ast::Pass checker( objDecl->type ); maybe_accept( objDecl->init.get(), checker ); return checker.core.result; @@ -102,10 +102,10 @@ std::vector< ast::ptr< ast::Expr > > makeInitList( const ast::Init * init ) { - ast::Pass< InitFlattener_new > flattener; + ast::Pass< InitFlattener > flattener; maybe_accept( init, flattener ); return std::move( flattener.core.argList ); } -class InitExpander_new::ExpanderImpl { +class InitExpander::ExpanderImpl { public: virtual ~ExpanderImpl() = default; @@ -137,5 +137,5 @@ template< typename Out > void build( - ast::UntypedExpr * callExpr, const InitExpander_new::IndexList & indices, + ast::UntypedExpr * callExpr, const InitExpander::IndexList & indices, const ast::Init * init, Out & out ) { @@ -183,15 +183,15 @@ } - class InitImpl_new final : public InitExpander_new::ExpanderImpl { + class InitImpl final : public InitExpander::ExpanderImpl { ast::ptr< ast::Init > init; public: - InitImpl_new( const ast::Init * i ) : init( i ) {} - - std::vector< ast::ptr< ast::Expr > > next( InitExpander_new::IndexList & ) override { + InitImpl( const ast::Init * i ) : init( i ) {} + + std::vector< ast::ptr< ast::Expr > > next( InitExpander::IndexList & ) override { return makeInitList( init ); } ast::ptr< ast::Stmt > buildListInit( - ast::UntypedExpr * callExpr, InitExpander_new::IndexList & indices + ast::UntypedExpr * callExpr, InitExpander::IndexList & indices ) override { // If array came with an initializer list, initialize each element. We may have more @@ -215,11 +215,11 @@ }; - class ExprImpl_new final : public InitExpander_new::ExpanderImpl { + class ExprImpl final : public InitExpander::ExpanderImpl { ast::ptr< ast::Expr > arg; public: - ExprImpl_new( const ast::Expr * a ) : arg( a ) {} + ExprImpl( const ast::Expr * a ) : arg( a ) {} std::vector< ast::ptr< ast::Expr > > next( - InitExpander_new::IndexList & indices + InitExpander::IndexList & indices ) override { if ( ! arg ) return {}; @@ -237,5 +237,5 @@ ast::ptr< ast::Stmt > buildListInit( - ast::UntypedExpr *, InitExpander_new::IndexList & + ast::UntypedExpr *, InitExpander::IndexList & ) override { return {}; @@ -244,13 +244,13 @@ } // anonymous namespace -InitExpander_new::InitExpander_new( const ast::Init * init ) -: expander( new InitImpl_new{ init } ), crnt(), indices() {} - -InitExpander_new::InitExpander_new( const ast::Expr * expr ) -: expander( new ExprImpl_new{ expr } ), crnt(), indices() {} - -std::vector< ast::ptr< ast::Expr > > InitExpander_new::operator* () { return crnt; } - -InitExpander_new & InitExpander_new::operator++ () { +InitExpander::InitExpander( const ast::Init * init ) +: expander( new InitImpl{ init } ), crnt(), indices() {} + +InitExpander::InitExpander( const ast::Expr * expr ) +: expander( new ExprImpl{ expr } ), crnt(), indices() {} + +std::vector< ast::ptr< ast::Expr > > InitExpander::operator* () { return crnt; } + +InitExpander & InitExpander::operator++ () { crnt = expander->next( indices ); return *this; @@ -259,16 +259,16 @@ /// builds statement which has the same semantics as a C-style list initializer (for array /// initializers) using callExpr as the base expression to perform initialization -ast::ptr< ast::Stmt > InitExpander_new::buildListInit( ast::UntypedExpr * callExpr ) { +ast::ptr< ast::Stmt > InitExpander::buildListInit( ast::UntypedExpr * callExpr ) { return expander->buildListInit( callExpr, indices ); } -void InitExpander_new::addArrayIndex( const ast::Expr * index, const ast::Expr * dimension ) { +void InitExpander::addArrayIndex( const ast::Expr * index, const ast::Expr * dimension ) { indices.emplace_back( index ); indices.emplace_back( dimension ); } -void InitExpander_new::clearArrayIndices() { indices.clear(); } - -bool InitExpander_new::addReference() { +void InitExpander::clearArrayIndices() { indices.clear(); } + +bool InitExpander::addReference() { for ( ast::ptr< ast::Expr > & expr : crnt ) { expr = new ast::AddressExpr{ expr }; @@ -308,9 +308,9 @@ } - struct CallFinder_new final { + struct CallFinder final { std::vector< const ast::Expr * > matches; const std::vector< std::string > names; - CallFinder_new( std::vector< std::string > && ns ) : matches(), names( std::move(ns) ) {} + CallFinder( std::vector< std::string > && ns ) : matches(), names( std::move(ns) ) {} void handleCallExpr( const ast::Expr * expr ) { @@ -326,5 +326,5 @@ std::vector< const ast::Expr * > collectCtorDtorCalls( const ast::Stmt * stmt ) { - ast::Pass< CallFinder_new > finder{ std::vector< std::string >{ "?{}", "^?{}" } }; + ast::Pass< CallFinder > finder{ std::vector< std::string >{ "?{}", "^?{}" } }; maybe_accept( stmt, finder ); return std::move( finder.core.matches ); @@ -381,5 +381,5 @@ } - struct ConstExprChecker_new : public ast::WithShortCircuiting { + struct ConstExprChecker : public ast::WithShortCircuiting { // most expressions are not const expr void previsit( const ast::Expr * ) { result = false; visit_children = false; } @@ -426,5 +426,5 @@ bool isConstExpr( const ast::Expr * expr ) { if ( expr ) { - ast::Pass checker; + ast::Pass checker; expr->accept( checker ); return checker.core.result; @@ -435,5 +435,5 @@ bool isConstExpr( const ast::Init * init ) { if ( init ) { - ast::Pass checker; + ast::Pass checker; init->accept( checker ); return checker.core.result; @@ -486,3 +486,3 @@ } -} +} // namespace InitTweak Index: src/InitTweak/InitTweak.h =================================================================== --- src/InitTweak/InitTweak.h (revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9) +++ src/InitTweak/InitTweak.h (revision aad677d7c2bd4b3b3e41d177e27db0dfdaba484f) @@ -79,5 +79,5 @@ void addDataSectionAttribute( ast::ObjectDecl * objDecl ); - class InitExpander_new { + class InitExpander final { public: using IndexList = std::vector< ast::ptr< ast::Expr > >; @@ -92,11 +92,11 @@ public: /// Expand by stepping through init to get each list of arguments - InitExpander_new( const ast::Init * init ); + InitExpander( const ast::Init * init ); /// Always expand to expression - InitExpander_new( const ast::Expr * expr ); + InitExpander( const ast::Expr * expr ); std::vector< ast::ptr< ast::Expr > > operator* (); - InitExpander_new & operator++ (); + InitExpander & operator++ (); /// builds statement which has the same semantics as a C-style list initializer (for array @@ -111,5 +111,5 @@ bool addReference(); }; -} // namespace +} // namespace InitTweak // Local Variables: //