Index: src/AST/SymbolTable.cpp =================================================================== --- src/AST/SymbolTable.cpp (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/AST/SymbolTable.cpp (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -39,5 +39,5 @@ static inline auto stats() { using namespace Stats::Counters; - static auto group = build("Indexers"); + static auto group = build("Symbol Tables"); static struct { SimpleCounter * count; Index: src/AST/SymbolTable.hpp =================================================================== --- src/AST/SymbolTable.hpp (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/AST/SymbolTable.hpp (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -88,5 +88,5 @@ using Ptr = std::shared_ptr; - Ptr prevScope; ///< Indexer for parent scope + Ptr prevScope; ///< Symbol Table for parent scope unsigned long scope; ///< Scope index of this indexer unsigned long repScope; ///< Scope index of currently represented scope Index: src/CodeGen/CodeGeneratorNew.cpp =================================================================== --- src/CodeGen/CodeGeneratorNew.cpp (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/CodeGen/CodeGeneratorNew.cpp (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -24,5 +24,5 @@ namespace CodeGen { -int CodeGenerator_new::tabsize = 4; +int CodeGenerator::tabsize = 4; // The kinds of statements that should be followed by whitespace. @@ -35,13 +35,13 @@ } -void CodeGenerator_new::extension( ast::Expr const * expr ) { +void CodeGenerator::extension( ast::Expr const * expr ) { if ( expr->extension ) output << "__extension__ "; } -void CodeGenerator_new::extension( ast::Decl const * decl ) { +void CodeGenerator::extension( ast::Decl const * decl ) { if ( decl->extension ) output << "__extension__ "; } -void CodeGenerator_new::asmName( ast::DeclWithType const * decl ) { +void CodeGenerator::asmName( ast::DeclWithType const * decl ) { if ( auto asmName = decl->asmName.as() ) { output << " asm ( " << asmName->rep << " )"; @@ -49,5 +49,5 @@ } -CodeGenerator_new::LabelPrinter & CodeGenerator_new::LabelPrinter::operator()( +CodeGenerator::LabelPrinter & CodeGenerator::LabelPrinter::operator()( std::vector const & l ) { labels = &l; @@ -55,5 +55,5 @@ } -std::ostream & CodeGenerator_new::LabelPrinter::operator()( std::ostream & output ) const { +std::ostream & CodeGenerator::LabelPrinter::operator()( std::ostream & output ) const { const std::vector & labels = *this->labels; for ( const ast::Label & label : labels ) { @@ -66,5 +66,5 @@ // Using updateLocation at the beginning of a node and endl within a node // should become the method of formating. -void CodeGenerator_new::updateLocation( CodeLocation const & to ) { +void CodeGenerator::updateLocation( CodeLocation const & to ) { // Skip if linemarks shouldn't appear or if location is unset. if ( !options.lineMarks || to.isUnset() ) return; @@ -86,9 +86,9 @@ } -void CodeGenerator_new::updateLocation( ast::ParseNode const * to ) { +void CodeGenerator::updateLocation( ast::ParseNode const * to ) { updateLocation( to->location ); } -std::ostream & CodeGenerator_new::LineEnder::operator()( std::ostream & os ) const { +std::ostream & CodeGenerator::LineEnder::operator()( std::ostream & os ) const { os << "\n" << std::flush; cg.currentLocation.first_line++; @@ -96,10 +96,10 @@ } -CodeGenerator_new::CodeGenerator_new( std::ostream & os, const Options & options ) : - indent( 0, CodeGenerator_new::tabsize ), output( os ), +CodeGenerator::CodeGenerator( std::ostream & os, const Options & options ) : + indent( 0, CodeGenerator::tabsize ), output( os ), options( options ), printLabels( *this ), endl( *this ) {} -std::string CodeGenerator_new::mangleName( ast::DeclWithType const * decl ) { +std::string CodeGenerator::mangleName( ast::DeclWithType const * decl ) { // GCC builtins should always be printed unmangled. if ( options.pretty || decl->linkage.is_gcc_builtin ) { @@ -112,5 +112,5 @@ } -void CodeGenerator_new::genAttributes( +void CodeGenerator::genAttributes( const std::vector> & attributes ) { if ( attributes.empty() ) return; @@ -129,5 +129,5 @@ } -void CodeGenerator_new::previsit( ast::Node const * ) { +void CodeGenerator::previsit( ast::Node const * ) { // All traversal is manual. // TODO: Which means the ast::Pass is just providing a default no visit? @@ -135,10 +135,10 @@ } -void CodeGenerator_new::previsit( ast::ParseNode const * node ) { +void CodeGenerator::previsit( ast::ParseNode const * node ) { previsit( (ast::Node const *)node ); updateLocation( node ); } -void CodeGenerator_new::postvisit( ast::Node const * node ) { +void CodeGenerator::postvisit( ast::Node const * node ) { std::stringstream ss; ast::print( ss, node ); @@ -146,5 +146,5 @@ } -void CodeGenerator_new::previsit( ast::Expr const * expr ) { +void CodeGenerator::previsit( ast::Expr const * expr ) { previsit( (ast::ParseNode const *)expr ); GuardAction( [this, expr](){ @@ -155,5 +155,5 @@ } -void CodeGenerator_new::postvisit( ast::FunctionDecl const * decl ) { +void CodeGenerator::postvisit( ast::FunctionDecl const * decl ) { // Deleted decls should never be used, so don't print them in C. if ( decl->isDeleted && options.genC ) return; @@ -168,5 +168,5 @@ std::ostringstream acc; - ast::Pass subCG( acc, subOptions ); + ast::Pass subCG( acc, subOptions ); // Add the forall clause. // TODO: These probably should be removed by now and the assert used. @@ -213,6 +213,5 @@ } -//void CodeGenerator_new::postvisit( ast::ObjectDecl const * decl_ ) { -ast::ObjectDecl const * CodeGenerator_new::postvisit( +ast::ObjectDecl const * CodeGenerator::postvisit( ast::ObjectDecl const * decl ) { // Deleted decls should never be used, so don't print them in C. @@ -262,5 +261,5 @@ } -void CodeGenerator_new::handleStorageClass( ast::DeclWithType const * decl ) { +void CodeGenerator::handleStorageClass( ast::DeclWithType const * decl ) { if ( decl->storage.any() ) { ast::print( output, decl->storage ); @@ -268,5 +267,5 @@ } -void CodeGenerator_new::handleAggregate( +void CodeGenerator::handleAggregate( ast::AggregateDecl const * decl, std::string const & kind ) { if ( !decl->params.empty() && !options.genC ) { @@ -296,10 +295,10 @@ } -void CodeGenerator_new::postvisit( ast::StructDecl const * decl ) { +void CodeGenerator::postvisit( ast::StructDecl const * decl ) { extension( decl ); handleAggregate( decl, "struct " ); } -void CodeGenerator_new::postvisit( ast::UnionDecl const * decl ) { +void CodeGenerator::postvisit( ast::UnionDecl const * decl ) { extension( decl ); handleAggregate( decl, "union " ); @@ -332,5 +331,5 @@ } -void CodeGenerator_new::postvisit( ast::EnumDecl const * decl ) { +void CodeGenerator::postvisit( ast::EnumDecl const * decl ) { extension( decl ); auto members = decl->members; @@ -370,5 +369,5 @@ } -void CodeGenerator_new::postvisit( ast::TraitDecl const * decl ) { +void CodeGenerator::postvisit( ast::TraitDecl const * decl ) { assertf( !options.genC, "TraitDecls should not reach code generation." ); extension( decl ); @@ -376,10 +375,10 @@ } -void CodeGenerator_new::postvisit( ast::TypedefDecl const * decl ) { +void CodeGenerator::postvisit( ast::TypedefDecl const * decl ) { assertf( !options.genC, "Typedefs should not reach code generation." ); output << "typedef " << genType( decl->base, decl->name, options ) << endl; } -void CodeGenerator_new::postvisit( ast::TypeDecl const * decl ) { +void CodeGenerator::postvisit( ast::TypeDecl const * decl ) { assertf( !options.genC, "TypeDecls should not reach code generation." ); output << decl->genTypeString() << " " << decl->name; @@ -397,5 +396,5 @@ } -void CodeGenerator_new::postvisit( ast::StaticAssertDecl const * decl ) { +void CodeGenerator::postvisit( ast::StaticAssertDecl const * decl ) { output << "_Static_assert("; decl->cond->accept( *visitor ); @@ -405,5 +404,5 @@ } -void CodeGenerator_new::postvisit( ast::Designation const * designation ) { +void CodeGenerator::postvisit( ast::Designation const * designation ) { auto designators = designation->designators; if ( 0 == designators.size() ) return; @@ -423,9 +422,9 @@ } -void CodeGenerator_new::postvisit( ast::SingleInit const * init ) { +void CodeGenerator::postvisit( ast::SingleInit const * init ) { init->value->accept( *visitor ); } -void CodeGenerator_new::postvisit( ast::ListInit const * init ) { +void CodeGenerator::postvisit( ast::ListInit const * init ) { auto initBegin = init->initializers.begin(); auto initEnd = init->initializers.end(); @@ -446,5 +445,5 @@ } -void CodeGenerator_new::postvisit( ast::ConstructorInit const * init ) { +void CodeGenerator::postvisit( ast::ConstructorInit const * init ) { assertf( !options.genC, "ConstructorInit nodes should not reach code generation." ); // This isn't actual code, but labels the constructor/destructor pairs. @@ -456,5 +455,5 @@ } -void CodeGenerator_new::postvisit( ast::ApplicationExpr const * expr ) { +void CodeGenerator::postvisit( ast::ApplicationExpr const * expr ) { extension( expr ); if ( auto var = expr->func.as() ) { @@ -550,5 +549,5 @@ } -void CodeGenerator_new::postvisit( ast::UntypedExpr const * expr ) { +void CodeGenerator::postvisit( ast::UntypedExpr const * expr ) { extension( expr ); if ( auto name = expr->func.as() ) { @@ -638,5 +637,5 @@ } -void CodeGenerator_new::postvisit( ast::RangeExpr const * expr ) { +void CodeGenerator::postvisit( ast::RangeExpr const * expr ) { expr->low->accept( *visitor ); output << " ... "; @@ -644,5 +643,5 @@ } -void CodeGenerator_new::postvisit( ast::NameExpr const * expr ) { +void CodeGenerator::postvisit( ast::NameExpr const * expr ) { extension( expr ); if ( const OperatorInfo * opInfo = operatorLookup( expr->name ) ) { @@ -657,10 +656,10 @@ } -void CodeGenerator_new::postvisit( ast::DimensionExpr const * expr ) { +void CodeGenerator::postvisit( ast::DimensionExpr const * expr ) { extension( expr ); output << "/*non-type*/" << expr->name; } -void CodeGenerator_new::postvisit( ast::AddressExpr const * expr ) { +void CodeGenerator::postvisit( ast::AddressExpr const * expr ) { extension( expr ); output << "(&"; @@ -669,10 +668,10 @@ } -void CodeGenerator_new::postvisit( ast::LabelAddressExpr const * expr ) { +void CodeGenerator::postvisit( ast::LabelAddressExpr const * expr ) { extension( expr ); output << "(&&" << expr->arg << ")"; } -void CodeGenerator_new::postvisit( ast::CastExpr const * expr ) { +void CodeGenerator::postvisit( ast::CastExpr const * expr ) { extension( expr ); output << "("; @@ -688,5 +687,5 @@ } -void CodeGenerator_new::postvisit( ast::KeywordCastExpr const * expr ) { +void CodeGenerator::postvisit( ast::KeywordCastExpr const * expr ) { assertf( !options.genC, "KeywordCastExpr should not reach code generation." ); extension( expr ); @@ -696,5 +695,5 @@ } -void CodeGenerator_new::postvisit( ast::VirtualCastExpr const * expr ) { +void CodeGenerator::postvisit( ast::VirtualCastExpr const * expr ) { assertf( !options.genC, "VirtualCastExpr should not reach code generation." ); extension( expr ); @@ -705,5 +704,5 @@ } -void CodeGenerator_new::postvisit( ast::UntypedMemberExpr const * expr ) { +void CodeGenerator::postvisit( ast::UntypedMemberExpr const * expr ) { assertf( !options.genC, "UntypedMemberExpr should not reach code generation." ); extension( expr ); @@ -713,5 +712,5 @@ } -void CodeGenerator_new::postvisit( ast::MemberExpr const * expr ) { +void CodeGenerator::postvisit( ast::MemberExpr const * expr ) { extension( expr ); expr->aggregate->accept( *visitor ); @@ -719,5 +718,5 @@ } -void CodeGenerator_new::postvisit( ast::VariableExpr const * expr ) { +void CodeGenerator::postvisit( ast::VariableExpr const * expr ) { extension( expr ); const OperatorInfo * opInfo; @@ -733,10 +732,10 @@ } -void CodeGenerator_new::postvisit( ast::ConstantExpr const * expr ) { +void CodeGenerator::postvisit( ast::ConstantExpr const * expr ) { extension( expr ); output << expr->rep; } -void CodeGenerator_new::postvisit( ast::SizeofExpr const * expr ) { +void CodeGenerator::postvisit( ast::SizeofExpr const * expr ) { extension( expr ); output << "sizeof("; @@ -749,5 +748,5 @@ } -void CodeGenerator_new::postvisit( ast::AlignofExpr const * expr ) { +void CodeGenerator::postvisit( ast::AlignofExpr const * expr ) { // Using the GCC extension to avoid changing the std to C11. extension( expr ); @@ -761,5 +760,5 @@ } -void CodeGenerator_new::postvisit( ast::UntypedOffsetofExpr const * expr ) { +void CodeGenerator::postvisit( ast::UntypedOffsetofExpr const * expr ) { assertf( !options.genC, "UntypedOffsetofExpr should not reach code generation." ); output << "offsetof("; @@ -769,5 +768,5 @@ } -void CodeGenerator_new::postvisit( ast::OffsetofExpr const * expr ) { +void CodeGenerator::postvisit( ast::OffsetofExpr const * expr ) { // Use GCC builtin output << "__builtin_offsetof("; @@ -777,10 +776,10 @@ } -void CodeGenerator_new::postvisit( ast::OffsetPackExpr const * expr ) { +void CodeGenerator::postvisit( ast::OffsetPackExpr const * expr ) { assertf( !options.genC, "OffsetPackExpr should not reach code generation." ); output << "__CFA_offsetpack(" << genType( expr->type, "", options ) << ")"; } -void CodeGenerator_new::postvisit( ast::LogicalExpr const * expr ) { +void CodeGenerator::postvisit( ast::LogicalExpr const * expr ) { extension( expr ); output << "("; @@ -791,5 +790,5 @@ } -void CodeGenerator_new::postvisit( ast::ConditionalExpr const * expr ) { +void CodeGenerator::postvisit( ast::ConditionalExpr const * expr ) { extension( expr ); output << "("; @@ -802,5 +801,5 @@ } -void CodeGenerator_new::postvisit( ast::CommaExpr const * expr ) { +void CodeGenerator::postvisit( ast::CommaExpr const * expr ) { extension( expr ); output << "("; @@ -818,10 +817,10 @@ } -void CodeGenerator_new::postvisit( ast::TupleAssignExpr const * expr ) { +void CodeGenerator::postvisit( ast::TupleAssignExpr const * expr ) { assertf( !options.genC, "TupleAssignExpr should not reach code generation." ); expr->stmtExpr->accept( *visitor ); } -void CodeGenerator_new::postvisit( ast::UntypedTupleExpr const * expr ) { +void CodeGenerator::postvisit( ast::UntypedTupleExpr const * expr ) { assertf( !options.genC, "UntypedTupleExpr should not reach code generation." ); extension( expr ); @@ -831,5 +830,5 @@ } -void CodeGenerator_new::postvisit( ast::TupleExpr const * expr ) { +void CodeGenerator::postvisit( ast::TupleExpr const * expr ) { assertf( !options.genC, "TupleExpr should not reach code generation." ); extension( expr ); @@ -839,5 +838,5 @@ } -void CodeGenerator_new::postvisit( ast::TupleIndexExpr const * expr ) { +void CodeGenerator::postvisit( ast::TupleIndexExpr const * expr ) { assertf( !options.genC, "TupleIndexExpr should not reach code generation." ); extension( expr ); @@ -846,5 +845,5 @@ } -void CodeGenerator_new::postvisit( ast::TypeExpr const * expr ) { +void CodeGenerator::postvisit( ast::TypeExpr const * expr ) { // TODO: Should there be an assertion there? if ( !options.genC ) { @@ -853,5 +852,5 @@ } -void CodeGenerator_new::postvisit( ast::AsmExpr const * expr ) { +void CodeGenerator::postvisit( ast::AsmExpr const * expr ) { if ( !expr->inout.empty() ) { output << "[ " << expr->inout << " ] "; @@ -863,5 +862,5 @@ } -void CodeGenerator_new::postvisit( ast::CompoundLiteralExpr const * expr ) { +void CodeGenerator::postvisit( ast::CompoundLiteralExpr const * expr ) { //assert( expr->result && dynamic_cast( expr->init ) ); assert( expr->result && expr->init.as() ); @@ -870,5 +869,5 @@ } -void CodeGenerator_new::postvisit( ast::UniqueExpr const * expr ) { +void CodeGenerator::postvisit( ast::UniqueExpr const * expr ) { assertf( !options.genC, "UniqueExpr should not reach code generation." ); output << "unq<" << expr->id << ">{ "; @@ -877,5 +876,5 @@ } -void CodeGenerator_new::postvisit( ast::StmtExpr const * expr ) { +void CodeGenerator::postvisit( ast::StmtExpr const * expr ) { auto stmts = expr->stmts->kids; output << "({" << endl; @@ -905,20 +904,20 @@ } -void CodeGenerator_new::postvisit( ast::ConstructorExpr const * expr ) { +void CodeGenerator::postvisit( ast::ConstructorExpr const * expr ) { assertf( !options.genC, "ConstructorExpr should not reach code generation." ); expr->callExpr->accept( *visitor ); } -void CodeGenerator_new::postvisit( ast::DeletedExpr const * expr ) { +void CodeGenerator::postvisit( ast::DeletedExpr const * expr ) { assertf( !options.genC, "DeletedExpr should not reach code generation." ); expr->expr->accept( *visitor ); } -void CodeGenerator_new::postvisit( ast::DefaultArgExpr const * expr ) { +void CodeGenerator::postvisit( ast::DefaultArgExpr const * expr ) { assertf( !options.genC, "DefaultArgExpr should not reach code generation." ); expr->expr->accept( *visitor ); } -void CodeGenerator_new::postvisit( ast::GenericExpr const * expr ) { +void CodeGenerator::postvisit( ast::GenericExpr const * expr ) { assertf( !options.genC, "GenericExpr should not reach code generation." ); output << "_Generic("; @@ -940,5 +939,5 @@ } -void CodeGenerator_new::postvisit( ast::CompoundStmt const * stmt ) { +void CodeGenerator::postvisit( ast::CompoundStmt const * stmt ) { output << "{" << endl; @@ -955,5 +954,5 @@ } -void CodeGenerator_new::postvisit( ast::ExprStmt const * stmt ) { +void CodeGenerator::postvisit( ast::ExprStmt const * stmt ) { assert( stmt ); // Cast the top-level expression to void to reduce gcc warnings. @@ -967,5 +966,5 @@ } -void CodeGenerator_new::postvisit( ast::AsmStmt const * stmt ) { +void CodeGenerator::postvisit( ast::AsmStmt const * stmt ) { output << "asm "; if ( stmt->isVolatile ) output << "volatile "; @@ -991,5 +990,5 @@ } -void CodeGenerator_new::postvisit( ast::AsmDecl const * decl ) { +void CodeGenerator::postvisit( ast::AsmDecl const * decl ) { output << "asm "; ast::AsmStmt const * stmt = decl->stmt; @@ -999,15 +998,15 @@ } -void CodeGenerator_new::postvisit( ast::DirectiveDecl const * decl ) { +void CodeGenerator::postvisit( ast::DirectiveDecl const * decl ) { // endl prevents spaces before the directive. output << endl << decl->stmt->directive; } -void CodeGenerator_new::postvisit( ast::DirectiveStmt const * stmt ) { +void CodeGenerator::postvisit( ast::DirectiveStmt const * stmt ) { // endl prevents spaces before the directive. output << endl << stmt->directive; } -void CodeGenerator_new::postvisit( ast::IfStmt const * stmt ) { +void CodeGenerator::postvisit( ast::IfStmt const * stmt ) { output << "if ( "; stmt->cond->accept( *visitor ); @@ -1022,5 +1021,5 @@ } -void CodeGenerator_new::postvisit( ast::SwitchStmt const * stmt ) { +void CodeGenerator::postvisit( ast::SwitchStmt const * stmt ) { output << "switch ( "; stmt->cond->accept( *visitor ); @@ -1036,5 +1035,5 @@ } -void CodeGenerator_new::postvisit( ast::CaseClause const * clause ) { +void CodeGenerator::postvisit( ast::CaseClause const * clause ) { updateLocation( clause ); output << indent; @@ -1056,5 +1055,5 @@ } -void CodeGenerator_new::postvisit( ast::BranchStmt const * stmt ) { +void CodeGenerator::postvisit( ast::BranchStmt const * stmt ) { switch ( stmt->kind ) { case ast::BranchStmt::Goto: @@ -1091,5 +1090,5 @@ } -void CodeGenerator_new::postvisit( ast::ReturnStmt const * stmt ) { +void CodeGenerator::postvisit( ast::ReturnStmt const * stmt ) { output << "return "; if ( stmt->expr ) stmt->expr->accept( *visitor ); @@ -1097,5 +1096,5 @@ } -void CodeGenerator_new::postvisit( ast::ThrowStmt const * stmt ) { +void CodeGenerator::postvisit( ast::ThrowStmt const * stmt ) { assertf( !options.genC, "ThrowStmt should not reach code generation." ); @@ -1112,5 +1111,5 @@ } -void CodeGenerator_new::postvisit( ast::CatchClause const * stmt ) { +void CodeGenerator::postvisit( ast::CatchClause const * stmt ) { assertf( !options.genC, "CatchClause should not reach code generation." ); @@ -1126,5 +1125,5 @@ } -void CodeGenerator_new::postvisit( ast::WaitForStmt const * stmt ) { +void CodeGenerator::postvisit( ast::WaitForStmt const * stmt ) { assertf( !options.genC, "WaitforStmt should not reach code generation." ); @@ -1172,5 +1171,5 @@ } -void CodeGenerator_new::postvisit( ast::WithStmt const * stmt ) { +void CodeGenerator::postvisit( ast::WithStmt const * stmt ) { assertf( !options.genC, "WithStmt should not reach code generation." ); @@ -1181,5 +1180,5 @@ } -void CodeGenerator_new::postvisit( ast::WhileDoStmt const * stmt ) { +void CodeGenerator::postvisit( ast::WhileDoStmt const * stmt ) { if ( stmt->isDoWhile ) { output << "do"; @@ -1191,5 +1190,5 @@ output << " "; - output << CodeGenerator_new::printLabels( stmt->body->labels ); + output << CodeGenerator::printLabels( stmt->body->labels ); stmt->body->accept( *visitor ); @@ -1203,5 +1202,5 @@ } -void CodeGenerator_new::postvisit( ast::ForStmt const * stmt ) { +void CodeGenerator::postvisit( ast::ForStmt const * stmt ) { // Initializer is always hoised so don't generate it. // TODO: Do an assertion check? @@ -1226,9 +1225,9 @@ } -void CodeGenerator_new::postvisit( ast::NullStmt const * ) { +void CodeGenerator::postvisit( ast::NullStmt const * ) { output << "/* null statement */ ;"; } -void CodeGenerator_new::postvisit( ast::DeclStmt const * stmt ) { +void CodeGenerator::postvisit( ast::DeclStmt const * stmt ) { stmt->decl->accept( *visitor ); @@ -1236,10 +1235,10 @@ } -void CodeGenerator_new::postvisit( ast::ImplicitCtorDtorStmt const * stmt ) { +void CodeGenerator::postvisit( ast::ImplicitCtorDtorStmt const * stmt ) { assertf( !options.genC, "ImplicitCtorCtorStmt should not reach code generation." ); stmt->callStmt->accept( *visitor ); } -void CodeGenerator_new::postvisit( ast::MutexStmt const * stmt ) { +void CodeGenerator::postvisit( ast::MutexStmt const * stmt ) { assertf( !options.genC, "MutexStmt should not reach code generation." ); // TODO: But this isn't what a mutex statement looks like. Index: src/CodeGen/CodeGeneratorNew.hpp =================================================================== --- src/CodeGen/CodeGeneratorNew.hpp (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/CodeGen/CodeGeneratorNew.hpp (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -25,10 +25,9 @@ namespace CodeGen { -#warning Remove the _new when old version is removed. -struct CodeGenerator_new : +struct CodeGenerator final : public ast::WithGuards, public ast::WithShortCircuiting, - public ast::WithVisitorRef { - CodeGenerator_new( std::ostream & out, Options const & options ); + public ast::WithVisitorRef { + CodeGenerator( std::ostream & out, Options const & options ); // Turn off visit_children for all nodes. @@ -119,6 +118,6 @@ /// Custom local implementation of endl that updates print location. struct LineEnder { - CodeGenerator_new & cg; - LineEnder( CodeGenerator_new & cg ) : cg( cg ) {} + CodeGenerator & cg; + LineEnder( CodeGenerator & cg ) : cg( cg ) {} std::ostream & operator()( std::ostream & ) const; }; @@ -129,8 +128,8 @@ /// Wrapper class to help print vectors of Labels. struct LabelPrinter { - LabelPrinter( CodeGenerator_new & cg ) : cg( cg ), labels( nullptr ) {} + LabelPrinter( CodeGenerator & cg ) : cg( cg ), labels( nullptr ) {} LabelPrinter & operator()( std::vector const & l ); std::ostream & operator()( std::ostream & ) const; - CodeGenerator_new & cg; + CodeGenerator & cg; std::vector const * labels; }; Index: src/CodeGen/GenType.cc =================================================================== --- src/CodeGen/GenType.cc (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/CodeGen/GenType.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -21,5 +21,5 @@ #include "AST/Print.hpp" // for print #include "AST/Vector.hpp" // for vector -#include "CodeGeneratorNew.hpp" // for CodeGenerator_new +#include "CodeGeneratorNew.hpp" // for CodeGenerator #include "Common/UniqueName.h" // for UniqueName @@ -28,10 +28,9 @@ namespace { -#warning Remove the _new when old version is removed. -struct GenType_new : +struct GenType final : public ast::WithShortCircuiting, - public ast::WithVisitorRef { + public ast::WithVisitorRef { std::string result; - GenType_new( const std::string &typeString, const Options &options ); + GenType( const std::string &typeString, const Options &options ); void previsit( ast::Node const * ); @@ -67,7 +66,7 @@ }; -GenType_new::GenType_new( const std::string &typeString, const Options &options ) : result( typeString ), options( options ) {} - -void GenType_new::previsit( ast::Node const * ) { +GenType::GenType( const std::string &typeString, const Options &options ) : result( typeString ), options( options ) {} + +void GenType::previsit( ast::Node const * ) { // Turn off automatic recursion for all nodes, to allow each visitor to // precisely control the order in which its children are visited. @@ -75,5 +74,5 @@ } -void GenType_new::postvisit( ast::Node const * node ) { +void GenType::postvisit( ast::Node const * node ) { std::stringstream ss; ast::print( ss, node ); @@ -81,10 +80,10 @@ } -void GenType_new::postvisit( ast::VoidType const * type ) { +void GenType::postvisit( ast::VoidType const * type ) { result = "void " + result; handleQualifiers( type ); } -void GenType_new::postvisit( ast::BasicType const * type ) { +void GenType::postvisit( ast::BasicType const * type ) { ast::BasicType::Kind kind = type->kind; assert( 0 <= kind && kind < ast::BasicType::NUMBER_OF_BASIC_TYPES ); @@ -93,5 +92,5 @@ } -void GenType_new::genArray( const ast::CV::Qualifiers & qualifiers, ast::Type const * base, ast::Expr const *dimension, bool isVarLen, bool isStatic ) { +void GenType::genArray( const ast::CV::Qualifiers & qualifiers, ast::Type const * base, ast::Expr const *dimension, bool isVarLen, bool isStatic ) { std::ostringstream os; if ( result != "" ) { @@ -119,5 +118,5 @@ } if ( dimension != 0 ) { - ast::Pass::read( dimension, os, options ); + ast::Pass::read( dimension, os, options ); } else if ( isVarLen ) { // no dimension expression on a VLA means it came in with the * token @@ -131,5 +130,5 @@ } -void GenType_new::postvisit( ast::PointerType const * type ) { +void GenType::postvisit( ast::PointerType const * type ) { if ( type->isStatic || type->isVarLen || type->dimension ) { genArray( type->qualifiers, type->base, type->dimension, type->isVarLen, type->isStatic ); @@ -145,9 +144,9 @@ } -void GenType_new::postvisit( ast::ArrayType const * type ) { +void GenType::postvisit( ast::ArrayType const * type ) { genArray( type->qualifiers, type->base, type->dimension, type->isVarLen, type->isStatic ); } -void GenType_new::postvisit( ast::ReferenceType const * type ) { +void GenType::postvisit( ast::ReferenceType const * type ) { assertf( !options.genC, "Reference types should not reach code generation." ); handleQualifiers( type ); @@ -156,5 +155,5 @@ } -void GenType_new::postvisit( ast::FunctionType const * type ) { +void GenType::postvisit( ast::FunctionType const * type ) { std::ostringstream os; @@ -196,5 +195,5 @@ //assertf( !options.genC, "FunctionDecl type parameters should not reach code generation." ); std::ostringstream os; - ast::Pass cg( os, options ); + ast::Pass cg( os, options ); os << "forall("; cg.core.genCommaList( type->forall ); @@ -204,8 +203,8 @@ } -std::string GenType_new::handleGeneric( ast::BaseInstType const * type ) { +std::string GenType::handleGeneric( ast::BaseInstType const * type ) { if ( !type->params.empty() ) { std::ostringstream os; - ast::Pass cg( os, options ); + ast::Pass cg( os, options ); os << "("; cg.core.genCommaList( type->params ); @@ -216,5 +215,5 @@ } -void GenType_new::postvisit( ast::StructInstType const * type ) { +void GenType::postvisit( ast::StructInstType const * type ) { result = type->name + handleGeneric( type ) + " " + result; if ( options.genC ) result = "struct " + result; @@ -222,5 +221,5 @@ } -void GenType_new::postvisit( ast::UnionInstType const * type ) { +void GenType::postvisit( ast::UnionInstType const * type ) { result = type->name + handleGeneric( type ) + " " + result; if ( options.genC ) result = "union " + result; @@ -228,5 +227,5 @@ } -void GenType_new::postvisit( ast::EnumInstType const * type ) { +void GenType::postvisit( ast::EnumInstType const * type ) { if ( type->base && type->base->base ) { result = genType( type->base->base, result, options ); @@ -240,5 +239,5 @@ } -void GenType_new::postvisit( ast::TypeInstType const * type ) { +void GenType::postvisit( ast::TypeInstType const * type ) { assertf( !options.genC, "TypeInstType should not reach code generation." ); result = type->name + " " + result; @@ -246,5 +245,5 @@ } -void GenType_new::postvisit( ast::TupleType const * type ) { +void GenType::postvisit( ast::TupleType const * type ) { assertf( !options.genC, "TupleType should not reach code generation." ); unsigned int i = 0; @@ -259,10 +258,10 @@ } -void GenType_new::postvisit( ast::VarArgsType const * type ) { +void GenType::postvisit( ast::VarArgsType const * type ) { result = "__builtin_va_list " + result; handleQualifiers( type ); } -void GenType_new::postvisit( ast::ZeroType const * type ) { +void GenType::postvisit( ast::ZeroType const * type ) { // Ideally these wouldn't hit codegen at all, but should be safe to make them ints. result = (options.pretty ? "zero_t " : "long int ") + result; @@ -270,5 +269,5 @@ } -void GenType_new::postvisit( ast::OneType const * type ) { +void GenType::postvisit( ast::OneType const * type ) { // Ideally these wouldn't hit codegen at all, but should be safe to make them ints. result = (options.pretty ? "one_t " : "long int ") + result; @@ -276,10 +275,10 @@ } -void GenType_new::postvisit( ast::GlobalScopeType const * type ) { +void GenType::postvisit( ast::GlobalScopeType const * type ) { assertf( !options.genC, "GlobalScopeType should not reach code generation." ); handleQualifiers( type ); } -void GenType_new::postvisit( ast::TraitInstType const * type ) { +void GenType::postvisit( ast::TraitInstType const * type ) { assertf( !options.genC, "TraitInstType should not reach code generation." ); result = type->name + " " + result; @@ -287,8 +286,8 @@ } -void GenType_new::postvisit( ast::TypeofType const * type ) { +void GenType::postvisit( ast::TypeofType const * type ) { std::ostringstream os; os << "typeof("; - ast::Pass::read( type, os, options ); + ast::Pass::read( type, os, options ); os << ") " << result; result = os.str(); @@ -296,5 +295,5 @@ } -void GenType_new::postvisit( ast::VTableType const * type ) { +void GenType::postvisit( ast::VTableType const * type ) { assertf( !options.genC, "Virtual table types should not reach code generation." ); std::ostringstream os; @@ -304,5 +303,5 @@ } -void GenType_new::postvisit( ast::QualifiedType const * type ) { +void GenType::postvisit( ast::QualifiedType const * type ) { assertf( !options.genC, "QualifiedType should not reach code generation." ); std::ostringstream os; @@ -312,5 +311,5 @@ } -void GenType_new::handleQualifiers( ast::Type const * type ) { +void GenType::handleQualifiers( ast::Type const * type ) { if ( type->is_const() ) { result = "const " + result; @@ -327,5 +326,5 @@ } -std::string GenType_new::genParamList( const ast::vector & range ) { +std::string GenType::genParamList( const ast::vector & range ) { auto cur = range.begin(); auto end = range.end(); @@ -346,13 +345,13 @@ std::ostringstream os; if ( !type->attributes.empty() ) { - ast::Pass cg( os, options ); + ast::Pass cg( os, options ); cg.core.genAttributes( type->attributes ); } - return os.str() + ast::Pass::read( type, base, options ); + return os.str() + ast::Pass::read( type, base, options ); } std::string genTypeNoAttr( ast::Type const * type, const std::string & base, const Options & options ) { - return ast::Pass::read( type, base, options ); + return ast::Pass::read( type, base, options ); } Index: src/CodeGen/Generate.cc =================================================================== --- src/CodeGen/Generate.cc (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/CodeGen/Generate.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -19,5 +19,5 @@ #include // for operator<< -#include "CodeGeneratorNew.hpp" // for CodeGenerator_new, doSemicolon, ... +#include "CodeGeneratorNew.hpp" // for CodeGenerator, doSemicolon, ... #include "GenType.h" // for genPrettyType @@ -32,5 +32,5 @@ /// Removes various nodes that should not exist in CodeGen. - struct TreeCleaner_new { + struct TreeCleaner final { ast::CompoundStmt const * previsit( ast::CompoundStmt const * stmt ) { auto mutStmt = ast::mutate( stmt ); @@ -51,7 +51,7 @@ bool pretty, bool generateC, bool lineMarks, bool printExprTypes ) { erase_if( translationUnit.decls, shouldClean ); - ast::Pass::run( translationUnit ); + ast::Pass::run( translationUnit ); - ast::Pass cgv( os, + ast::Pass cgv( os, Options( pretty, generateC, lineMarks, printExprTypes ) ); for ( auto & decl : translationUnit.decls ) { Index: src/CodeGen/Generate.h =================================================================== --- src/CodeGen/Generate.h (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/CodeGen/Generate.h (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -17,8 +17,4 @@ #include // for ostream -#include // for list - -class BaseSyntaxNode; -class Declaration; namespace ast { Index: src/InitTweak/FixGlobalInit.cc =================================================================== --- src/InitTweak/FixGlobalInit.cc (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/InitTweak/FixGlobalInit.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -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 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/InitTweak/FixInitNew.cpp (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -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 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/InitTweak/GenInit.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -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 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/InitTweak/GenInit.h (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -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 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/InitTweak/InitTweak.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -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 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/InitTweak/InitTweak.h (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -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: // Index: src/ResolvExpr/AdjustExprType.cc =================================================================== --- src/ResolvExpr/AdjustExprType.cc (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/AdjustExprType.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -23,10 +23,10 @@ namespace { - class AdjustExprType_new final : public ast::WithShortCircuiting { + class AdjustExprType final : public ast::WithShortCircuiting { const ast::SymbolTable & symtab; public: const ast::TypeEnvironment & tenv; - AdjustExprType_new( const ast::TypeEnvironment & e, const ast::SymbolTable & syms ) + AdjustExprType( const ast::TypeEnvironment & e, const ast::SymbolTable & syms ) : symtab( syms ), tenv( e ) {} @@ -75,5 +75,5 @@ const ast::Type * type, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab ) { - ast::Pass adjuster{ env, symtab }; + ast::Pass adjuster{ env, symtab }; return type->accept( adjuster ); } Index: src/ResolvExpr/AdjustExprType.hpp =================================================================== --- src/ResolvExpr/AdjustExprType.hpp (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/AdjustExprType.hpp (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -16,8 +16,4 @@ #pragma once -class Type; -namespace SymTab { - class Indexer; -} namespace ast { class SymbolTable; @@ -27,19 +23,4 @@ namespace ResolvExpr { - -class TypeEnvironment; - -/// Replaces array types with the equivalent pointer, and function types with a pointer-to-function -void adjustExprType( Type *& type, const TypeEnvironment & env, const SymTab::Indexer & indexer ); - -/// Replaces array types with the equivalent pointer, and function types with a pointer-to-function using empty TypeEnvironment and Indexer. -void adjustExprType( Type *& type ); - -template< typename ForwardIterator > -void adjustExprTypeList( ForwardIterator begin, ForwardIterator end, const TypeEnvironment & env, const SymTab::Indexer & indexer ) { - while ( begin != end ) { - adjustExprType( *begin++, env, indexer ); - } // while -} /// Replaces array types with equivalent pointer, Index: src/ResolvExpr/CandidateFinder.cpp =================================================================== --- src/ResolvExpr/CandidateFinder.cpp (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/CandidateFinder.cpp (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -61,5 +61,5 @@ namespace { /// First index is which argument, second is which alternative, third is which exploded element - using ExplodedArgs_new = std::deque< std::vector< ExplodedArg > >; + using ExplodedArgs = std::deque< std::vector< ExplodedArg > >; /// Returns a list of alternatives with the minimum cost in the given list @@ -255,5 +255,5 @@ /// Gets the list of exploded candidates for this pack - const ExplodedArg & getExpl( const ExplodedArgs_new & args ) const { + const ExplodedArg & getExpl( const ExplodedArgs & args ) const { return args[ nextArg-1 ][ explAlt ]; } @@ -281,5 +281,5 @@ bool instantiateArgument( const CodeLocation & location, - const ast::Type * paramType, const ast::Init * init, const ExplodedArgs_new & args, + const ast::Type * paramType, const ast::Init * init, const ExplodedArgs & args, std::vector< ArgPack > & results, std::size_t & genStart, const ast::SymbolTable & symtab, unsigned nTuples = 0 @@ -618,5 +618,5 @@ const CodeLocation & location, const CandidateRef & func, const ast::FunctionType * funcType, - const ExplodedArgs_new & args, CandidateList & out ); + const ExplodedArgs & args, CandidateList & out ); /// Adds implicit struct-conversions to the alternative list @@ -737,5 +737,5 @@ const CodeLocation & location, const CandidateRef & func, const ast::FunctionType * funcType, - const ExplodedArgs_new & args, CandidateList & out + const ExplodedArgs & args, CandidateList & out ) { ast::OpenVarSet funcOpen; @@ -997,5 +997,5 @@ // pre-explode arguments - ExplodedArgs_new argExpansions; + ExplodedArgs argExpansions; for ( const CandidateFinder & args : argCandidates ) { argExpansions.emplace_back(); Index: src/ResolvExpr/CastCost.cc =================================================================== --- src/ResolvExpr/CastCost.cc (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/CastCost.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -26,5 +26,4 @@ #include "ResolvExpr/ConversionCost.h" // for conversionCost #include "ResolvExpr/PtrsCastable.hpp" // for ptrsCastable -#include "ResolvExpr/typeops.h" // for ptrsCastable #include "ResolvExpr/Unify.h" // for typesCompatibleIgnoreQualifiers @@ -38,12 +37,12 @@ namespace { - struct CastCost_new : public ConversionCost_new { - using ConversionCost_new::previsit; - using ConversionCost_new::postvisit; + struct CastCost : public ConversionCost { + using ConversionCost::previsit; + using ConversionCost::postvisit; - CastCost_new( + CastCost( const ast::Type * dst, bool srcIsLvalue, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, CostCalculation costFunc ) - : ConversionCost_new( dst, srcIsLvalue, symtab, env, costFunc ) {} + : ConversionCost( dst, srcIsLvalue, symtab, env, costFunc ) {} void postvisit( const ast::BasicType * basicType ) { @@ -85,13 +84,4 @@ }; - #warning For overload resolution between the two versions. - int localPtrsCastable(const ast::Type * t1, const ast::Type * t2, - const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) { - return ptrsCastable( t1, t2, symtab, env ); - } - Cost localCastCost( - const ast::Type * src, const ast::Type * dst, bool srcIsLvalue, - const ast::SymbolTable & symtab, const ast::TypeEnvironment & env - ) { return castCost( src, dst, srcIsLvalue, symtab, env ); } } // anonymous namespace @@ -136,11 +126,9 @@ } else if ( auto refType = dynamic_cast< const ast::ReferenceType * >( dst ) ) { PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; ) - #warning cast on ptrsCastable artifact of having two functions, remove when port done return convertToReferenceCost( - src, refType, srcIsLvalue, symtab, env, localPtrsCastable ); + src, refType, srcIsLvalue, symtab, env, ptrsCastable ); } else { - #warning cast on castCost artifact of having two functions, remove when port done - ast::Pass< CastCost_new > converter( - dst, srcIsLvalue, symtab, env, localCastCost ); + ast::Pass< CastCost > converter( + dst, srcIsLvalue, symtab, env, castCost ); src->accept( converter ); return converter.core.cost; Index: src/ResolvExpr/CastCost.hpp =================================================================== --- src/ResolvExpr/CastCost.hpp (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/CastCost.hpp (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -18,8 +18,4 @@ #include "ResolvExpr/Cost.h" // for Cost -class Type; -namespace SymTab { - class Indexer; -} namespace ast { class SymbolTable; @@ -30,9 +26,4 @@ namespace ResolvExpr { -class TypeEnvironment; - -Cost castCost( - const Type * src, const Type * dest, bool srcIsLvalue, - const SymTab::Indexer & indexer, const TypeEnvironment & env ); Cost castCost( const ast::Type * src, const ast::Type * dst, bool srcIsLvalue, Index: src/ResolvExpr/CommonType.cc =================================================================== --- src/ResolvExpr/CommonType.cc (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/CommonType.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -343,5 +343,5 @@ ); - class CommonType_new final : public ast::WithShortCircuiting { + class CommonType final : public ast::WithShortCircuiting { const ast::Type * type2; WidenMode widen; @@ -354,5 +354,5 @@ ast::ptr< ast::Type > result; - CommonType_new( + CommonType( const ast::Type * t2, WidenMode w, ast::TypeEnvironment & env, const ast::OpenVarSet & o, @@ -388,5 +388,4 @@ result = enumDecl->base.get(); } else { - #warning remove casts when `commonTypes` moved to new AST ast::BasicType::Kind kind = commonTypes[ basic->kind ][ ast::BasicType::SignedInt ]; if ( @@ -739,5 +738,5 @@ }; - // size_t CommonType_new::traceId = Stats::Heap::new_stacktrace_id("CommonType_new"); + // size_t CommonType::traceId = Stats::Heap::new_stacktrace_id("CommonType"); namespace { ast::ptr< ast::Type > handleReference( @@ -811,5 +810,5 @@ } // otherwise both are reference types of the same depth and this is handled by the visitor - ast::Pass visitor{ type2, widen, env, open, need, have }; + ast::Pass visitor{ type2, widen, env, open, need, have }; type1->accept( visitor ); // ast::ptr< ast::Type > result = visitor.core.result; Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/ConversionCost.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -153,13 +153,8 @@ namespace { - # warning For overload resolution between the two versions. int localPtrsAssignable(const ast::Type * t1, const ast::Type * t2, const ast::SymbolTable &, const ast::TypeEnvironment & env ) { return ptrsAssignable( t1, t2, env ); } - Cost localConversionCost( - const ast::Type * src, const ast::Type * dst, bool srcIsLvalue, - const ast::SymbolTable & symtab, const ast::TypeEnvironment & env - ) { return conversionCost( src, dst, srcIsLvalue, symtab, env ); } } @@ -191,5 +186,5 @@ return convertToReferenceCost( src, refType, srcIsLvalue, symtab, env, localPtrsAssignable ); } else { - return ast::Pass::read( src, dst, srcIsLvalue, symtab, env, localConversionCost ); + return ast::Pass::read( src, dst, srcIsLvalue, symtab, env, conversionCost ); } } @@ -232,5 +227,5 @@ } } else { - return ast::Pass::read( src, dst, srcIsLvalue, symtab, env, localConversionCost ); + return ast::Pass::read( src, dst, srcIsLvalue, symtab, env, conversionCost ); } } else { @@ -264,10 +259,10 @@ } -void ConversionCost_new::postvisit( const ast::VoidType * voidType ) { +void ConversionCost::postvisit( const ast::VoidType * voidType ) { (void)voidType; cost = Cost::infinity; } -void ConversionCost_new::conversionCostFromBasicToBasic( const ast::BasicType * src, const ast::BasicType* dest ) { +void ConversionCost::conversionCostFromBasicToBasic( const ast::BasicType * src, const ast::BasicType* dest ) { int tableResult = costMatrix[ src->kind ][ dest->kind ]; if ( tableResult == -1 ) { @@ -280,5 +275,5 @@ } -void ConversionCost_new::postvisit( const ast::BasicType * basicType ) { +void ConversionCost::postvisit( const ast::BasicType * basicType ) { if ( const ast::BasicType * dstAsBasic = dynamic_cast< const ast::BasicType * >( dst ) ) { conversionCostFromBasicToBasic( basicType, dstAsBasic ); @@ -286,5 +281,5 @@ const ast::EnumDecl * enumDecl = enumInst->base.get(); if ( enumDecl->isTyped && !enumDecl->base.get() ) { - cost = Cost::infinity; + cost = Cost::infinity; } else if ( const ast::Type * enumType = enumDecl->base.get() ) { if ( const ast::BasicType * enumTypeAsBasic = dynamic_cast(enumType) ) { @@ -299,5 +294,5 @@ } -void ConversionCost_new::postvisit( const ast::PointerType * pointerType ) { +void ConversionCost::postvisit( const ast::PointerType * pointerType ) { if ( const ast::PointerType * dstAsPtr = dynamic_cast< const ast::PointerType * >( dst ) ) { ast::CV::Qualifiers tq1 = pointerType->base->qualifiers; @@ -345,9 +340,9 @@ } -void ConversionCost_new::postvisit( const ast::ArrayType * arrayType ) { +void ConversionCost::postvisit( const ast::ArrayType * arrayType ) { (void)arrayType; } -void ConversionCost_new::postvisit( const ast::ReferenceType * refType ) { +void ConversionCost::postvisit( const ast::ReferenceType * refType ) { assert( nullptr == dynamic_cast< const ast::ReferenceType * >( dst ) ); @@ -367,9 +362,9 @@ } -void ConversionCost_new::postvisit( const ast::FunctionType * functionType ) { +void ConversionCost::postvisit( const ast::FunctionType * functionType ) { (void)functionType; } -void ConversionCost_new::postvisit( const ast::EnumInstType * enumInstType ) { +void ConversionCost::postvisit( const ast::EnumInstType * enumInstType ) { const ast::EnumDecl * baseEnum = enumInstType->base; if ( const ast::Type * baseType = baseEnum->base ) { @@ -384,9 +379,9 @@ } -void ConversionCost_new::postvisit( const ast::TraitInstType * traitInstType ) { +void ConversionCost::postvisit( const ast::TraitInstType * traitInstType ) { (void)traitInstType; } -void ConversionCost_new::postvisit( const ast::TypeInstType * typeInstType ) { +void ConversionCost::postvisit( const ast::TypeInstType * typeInstType ) { if ( const ast::EqvClass * eqv = env.lookup( *typeInstType ) ) { cost = costCalc( eqv->bound, dst, srcIsLvalue, symtab, env ); @@ -405,5 +400,5 @@ } -void ConversionCost_new::postvisit( const ast::TupleType * tupleType ) { +void ConversionCost::postvisit( const ast::TupleType * tupleType ) { Cost c = Cost::zero; if ( const ast::TupleType * dstAsTuple = dynamic_cast< const ast::TupleType * >( dst ) ) { @@ -427,5 +422,5 @@ } -void ConversionCost_new::postvisit( const ast::VarArgsType * varArgsType ) { +void ConversionCost::postvisit( const ast::VarArgsType * varArgsType ) { (void)varArgsType; if ( dynamic_cast< const ast::VarArgsType * >( dst ) ) { @@ -434,5 +429,5 @@ } -void ConversionCost_new::postvisit( const ast::ZeroType * zeroType ) { +void ConversionCost::postvisit( const ast::ZeroType * zeroType ) { (void)zeroType; if ( dynamic_cast< const ast::ZeroType * >( dst ) ) { @@ -461,10 +456,10 @@ } -void ConversionCost_new::postvisit( const ast::OneType * oneType ) { +void ConversionCost::postvisit( const ast::OneType * oneType ) { (void)oneType; if ( dynamic_cast< const ast::OneType * >( dst ) ) { cost = Cost::zero; } else if ( const ast::BasicType * dstAsBasic = - dynamic_cast< const ast::BasicType * >( dst ) ) { + dynamic_cast< const ast::BasicType * >( dst ) ) { int tableResult = costMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ]; if ( -1 == tableResult ) { @@ -475,9 +470,8 @@ cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] ); } - - // cost = Cost::zero; - } -} -// size_t ConversionCost_new::traceId = Stats::Heap::new_stacktrace_id("ConversionCost"); + } +} + +// size_t ConversionCost::traceId = Stats::Heap::new_stacktrace_id("ConversionCost"); } // namespace ResolvExpr Index: src/ResolvExpr/ConversionCost.h =================================================================== --- src/ResolvExpr/ConversionCost.h (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/ConversionCost.h (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -23,10 +23,5 @@ #include "AST/Pass.hpp" // for WithShortCircuiting -namespace SymTab { - class Indexer; -} // namespace SymTab - namespace ResolvExpr { - class TypeEnvironment; // Some function pointer types, differ in return type. @@ -44,6 +39,5 @@ PtrsCalculation func ); -#warning when the old ConversionCost is removed, get ride of the _new suffix. -class ConversionCost_new : public ast::WithShortCircuiting { +class ConversionCost : public ast::WithShortCircuiting { protected: const ast::Type * dst; @@ -57,5 +51,5 @@ Cost result() { return cost; } - ConversionCost_new( const ast::Type * dst, bool srcIsLvalue, const ast::SymbolTable & symtab, + ConversionCost( const ast::Type * dst, bool srcIsLvalue, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, CostCalculation costCalc ) : dst( dst ), srcIsLvalue( srcIsLvalue ), symtab( symtab ), env( env ), Index: src/ResolvExpr/FindOpenVars.cc =================================================================== --- src/ResolvExpr/FindOpenVars.cc (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/FindOpenVars.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -25,5 +25,5 @@ namespace { - struct FindOpenVars_new final : public ast::WithGuards { + struct FindOpenVars final : public ast::WithGuards { ast::OpenVarSet & open; ast::OpenVarSet & closed; @@ -33,5 +33,5 @@ bool nextIsOpen; - FindOpenVars_new( + FindOpenVars( ast::OpenVarSet & o, ast::OpenVarSet & c, ast::AssertionSet & n, ast::AssertionSet & h, ast::TypeEnvironment & env, FirstMode firstIsOpen ) @@ -73,5 +73,5 @@ const ast::Type * type, ast::OpenVarSet & open, ast::OpenVarSet & closed, ast::AssertionSet & need, ast::AssertionSet & have, ast::TypeEnvironment & env, FirstMode firstIsOpen ) { - ast::Pass< FindOpenVars_new > finder{ open, closed, need, have, env, firstIsOpen }; + ast::Pass< FindOpenVars > finder{ open, closed, need, have, env, firstIsOpen }; type->accept( finder ); Index: src/ResolvExpr/PolyCost.cc =================================================================== --- src/ResolvExpr/PolyCost.cc (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/PolyCost.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -21,6 +21,5 @@ namespace ResolvExpr { -// TODO: When the old PolyCost is torn out get rid of the _new suffix. -class PolyCost_new { +class PolyCost { const ast::SymbolTable &symtab; public: @@ -28,5 +27,5 @@ const ast::TypeEnvironment &env_; - PolyCost_new( const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) + PolyCost( const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) : symtab( symtab ), result( 0 ), env_( env ) {} @@ -49,5 +48,5 @@ const ast::Type * type, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) { - ast::Pass costing( symtab, env ); + ast::Pass costing( symtab, env ); type->accept( costing ); return (costing.core.result > 0) ? 1 : 0; Index: src/ResolvExpr/PolyCost.hpp =================================================================== --- src/ResolvExpr/PolyCost.hpp (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/PolyCost.hpp (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -16,8 +16,4 @@ #pragma once -class Type; -namespace SymTab { - class Indexer; -} namespace ast { class SymbolTable; @@ -28,8 +24,4 @@ namespace ResolvExpr { -class TypeEnvironment; - -int polyCost( Type * type, - const TypeEnvironment & env, const SymTab::Indexer & indexer ); int polyCost( const ast::Type * type, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ); Index: src/ResolvExpr/PtrsAssignable.cc =================================================================== --- src/ResolvExpr/PtrsAssignable.cc (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/PtrsAssignable.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -22,14 +22,13 @@ namespace ResolvExpr { -// TODO: Get rid of the `_new` suffix when the old version is removed. -struct PtrsAssignable_new : public ast::WithShortCircuiting { +struct PtrsAssignable : public ast::WithShortCircuiting { const ast::Type * dst; const ast::TypeEnvironment & typeEnv; int result; - PtrsAssignable_new( const ast::Type * dst, const ast::TypeEnvironment & env ) : + PtrsAssignable( const ast::Type * dst, const ast::TypeEnvironment & env ) : dst( dst ), typeEnv( env ), result( 0 ) {} - void previsit( Type * ) { visit_children = false; } + void previsit( ast::Type * ) { visit_children = false; } void postvisit( const ast::EnumInstType * ) { @@ -63,5 +62,5 @@ return -1; } else { - ast::Pass visitor( dst, env ); + ast::Pass visitor( dst, env ); src->accept( visitor ); return visitor.core.result; Index: src/ResolvExpr/PtrsAssignable.hpp =================================================================== --- src/ResolvExpr/PtrsAssignable.hpp (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/PtrsAssignable.hpp (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -16,5 +16,4 @@ #pragma once -class Type; namespace ast { class Type; @@ -24,8 +23,4 @@ namespace ResolvExpr { -class TypeEnvironment; - -int ptrsAssignable( const Type * src, const Type * dest, - const TypeEnvironment & env ); int ptrsAssignable( const ast::Type * src, const ast::Type * dst, const ast::TypeEnvironment & env ); Index: src/ResolvExpr/PtrsCastable.cc =================================================================== --- src/ResolvExpr/PtrsCastable.cc (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/PtrsCastable.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -55,5 +55,5 @@ } - class PtrsCastable_new : public ast::WithShortCircuiting { + class PtrsCastable : public ast::WithShortCircuiting { const ast::Type * dst; const ast::TypeEnvironment & env; @@ -62,5 +62,5 @@ int result; - PtrsCastable_new( + PtrsCastable( const ast::Type * d, const ast::TypeEnvironment & e, const ast::SymbolTable & syms ) : dst( d ), env( e ), symtab( syms ), result( 0 ) {} @@ -149,5 +149,5 @@ return objectCast( src, env, symtab ); } else { - return ast::Pass::read( src, dst, env, symtab ); + return ast::Pass::read( src, dst, env, symtab ); } } Index: src/ResolvExpr/PtrsCastable.hpp =================================================================== --- src/ResolvExpr/PtrsCastable.hpp (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/PtrsCastable.hpp (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -16,8 +16,4 @@ #pragma once -class Type; -namespace SymTab { - class Indexer; -} namespace ast { class SymbolTable; @@ -28,9 +24,4 @@ namespace ResolvExpr { -class TypeEnvironment; - -int ptrsCastable( - const Type * src, const Type * dst, - const TypeEnvironment & env, const SymTab::Indexer & indexer ); int ptrsCastable( const ast::Type * src, const ast::Type * dst, Index: src/ResolvExpr/RenameVars.cc =================================================================== --- src/ResolvExpr/RenameVars.cc (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/RenameVars.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -101,5 +101,5 @@ RenamingData renaming; - struct RenameVars_new : public ast::PureVisitor /*: public ast::WithForallSubstitutor*/ { + struct RenameVars final : public ast::PureVisitor /*: public ast::WithForallSubstitutor*/ { RenameMode mode; @@ -132,5 +132,5 @@ const ast::Type * renameTyVars( const ast::Type * t, RenameMode mode, bool reset ) { - ast::Pass renamer; + ast::Pass renamer; renamer.core.mode = mode; if (mode == GEN_USAGE && reset) { Index: src/ResolvExpr/ResolveTypeof.cc =================================================================== --- src/ResolvExpr/ResolveTypeof.cc (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/ResolveTypeof.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -33,8 +33,8 @@ namespace { -struct ResolveTypeof_new : public ast::WithShortCircuiting { +struct ResolveTypeof : public ast::WithShortCircuiting { const ResolveContext & context; - ResolveTypeof_new( const ResolveContext & context ) : + ResolveTypeof( const ResolveContext & context ) : context( context ) {} @@ -78,5 +78,5 @@ const ast::Type * resolveTypeof( const ast::Type * type , const ResolveContext & context ) { - ast::Pass< ResolveTypeof_new > mutator( context ); + ast::Pass< ResolveTypeof > mutator( context ); return type->accept( mutator ); } Index: src/ResolvExpr/ResolveTypeof.h =================================================================== --- src/ResolvExpr/ResolveTypeof.h (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/ResolveTypeof.h (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -16,8 +16,4 @@ #pragma once -class Type; -namespace SymTab { -class Indexer; -} // namespace SymTab namespace ast { class Type; @@ -28,9 +24,8 @@ struct ResolveContext; - Type *resolveTypeof( Type*, const SymTab::Indexer &indexer ); const ast::Type * resolveTypeof( const ast::Type *, const ResolveContext & ); const ast::Type * fixArrayType( const ast::Type *, const ResolveContext & ); const ast::ObjectDecl * fixObjectType( const ast::ObjectDecl * decl , const ResolveContext & ); - const ast::ObjectDecl * fixObjectInit( const ast::ObjectDecl * decl , const ResolveContext &); + const ast::ObjectDecl * fixObjectInit( const ast::ObjectDecl * decl , const ResolveContext & ); } // namespace ResolvExpr Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/Resolver.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -62,5 +62,5 @@ namespace { /// Finds deleted expressions in an expression tree - struct DeleteFinder_new final : public ast::WithShortCircuiting, public ast::WithVisitorRef { + struct DeleteFinder final : public ast::WithShortCircuiting, public ast::WithVisitorRef { const ast::DeletedExpr * result = nullptr; @@ -80,9 +80,9 @@ }; - struct ResolveDesignators_new final : public ast::WithShortCircuiting { + struct ResolveDesignators final : public ast::WithShortCircuiting { ResolveContext& context; bool result = false; - ResolveDesignators_new( ResolveContext& _context ): context{_context} {}; + ResolveDesignators( ResolveContext& _context ): context{_context} {}; void previsit( const ast::Node * ) { @@ -113,5 +113,5 @@ /// Check if this expression is or includes a deleted expression const ast::DeletedExpr * findDeletedExpr( const ast::Expr * expr ) { - return ast::Pass::read( expr ); + return ast::Pass::read( expr ); } @@ -203,5 +203,5 @@ /// Strips extraneous casts out of an expression - struct StripCasts_new final { + struct StripCasts final { const ast::Expr * postvisit( const ast::CastExpr * castExpr ) { if ( @@ -217,5 +217,5 @@ static void strip( ast::ptr< ast::Expr > & expr ) { - ast::Pass< StripCasts_new > stripper; + ast::Pass< StripCasts > stripper; expr = expr->accept( stripper ); } @@ -251,5 +251,5 @@ expr.get_and_mutate()->env = std::move( newenv ); // remove unncecessary casts - StripCasts_new::strip( expr ); + StripCasts::strip( expr ); } @@ -368,7 +368,7 @@ } - class Resolver_new final + class Resolver final : public ast::WithSymbolTable, public ast::WithGuards, - public ast::WithVisitorRef, public ast::WithShortCircuiting, + public ast::WithVisitorRef, public ast::WithShortCircuiting, public ast::WithStmtsToAdd<> { @@ -376,5 +376,5 @@ ast::CurrentObject currentObject; // for work previously in GenInit - static InitTweak::ManagedTypes_new managedTypes; + static InitTweak::ManagedTypes managedTypes; ResolveContext context; @@ -383,8 +383,8 @@ public: static size_t traceId; - Resolver_new( const ast::TranslationGlobal & global ) : + Resolver( const ast::TranslationGlobal & global ) : ast::WithSymbolTable(ast::SymbolTable::ErrorDetection::ValidateOnAdd), context{ symtab, global } {} - Resolver_new( const ResolveContext & context ) : + Resolver( const ResolveContext & context ) : ast::WithSymbolTable{ context.symtab }, context{ symtab, context.global } {} @@ -427,10 +427,10 @@ bool on_error(ast::ptr & decl); }; - // size_t Resolver_new::traceId = Stats::Heap::new_stacktrace_id("Resolver"); - - InitTweak::ManagedTypes_new Resolver_new::managedTypes; + // size_t Resolver::traceId = Stats::Heap::new_stacktrace_id("Resolver"); + + InitTweak::ManagedTypes Resolver::managedTypes; void resolve( ast::TranslationUnit& translationUnit ) { - ast::Pass< Resolver_new >::run( translationUnit, translationUnit.global ); + ast::Pass< Resolver >::run( translationUnit, translationUnit.global ); } @@ -439,5 +439,5 @@ ) { assert( ctorInit ); - ast::Pass< Resolver_new > resolver( context ); + ast::Pass< Resolver > resolver( context ); return ctorInit->accept( resolver ); } @@ -447,5 +447,5 @@ ) { assert( stmtExpr ); - ast::Pass< Resolver_new > resolver( context ); + ast::Pass< Resolver > resolver( context ); auto ret = mutate(stmtExpr->accept(resolver)); strict_dynamic_cast< ast::StmtExpr * >( ret )->computeResult(); @@ -489,5 +489,5 @@ } - const ast::FunctionDecl * Resolver_new::previsit( const ast::FunctionDecl * functionDecl ) { + const ast::FunctionDecl * Resolver::previsit( const ast::FunctionDecl * functionDecl ) { GuardValue( functionReturn ); @@ -563,5 +563,5 @@ } - const ast::FunctionDecl * Resolver_new::postvisit( const ast::FunctionDecl * functionDecl ) { + const ast::FunctionDecl * Resolver::postvisit( const ast::FunctionDecl * functionDecl ) { // default value expressions have an environment which shouldn't be there and trips up // later passes. @@ -591,5 +591,5 @@ } - const ast::ObjectDecl * Resolver_new::previsit( const ast::ObjectDecl * objectDecl ) { + const ast::ObjectDecl * Resolver::previsit( const ast::ObjectDecl * objectDecl ) { // To handle initialization of routine pointers [e.g. int (*fp)(int) = foo()], // class-variable `initContext` is changed multiple times because the LHS is analyzed @@ -630,5 +630,5 @@ // constructed objects cannot be designated if ( InitTweak::isDesignated( mutDecl->init ) ) { - ast::Pass res( context ); + ast::Pass res( context ); maybe_accept( mutDecl->init.get(), res ); if ( !res.core.result ) { @@ -650,5 +650,5 @@ } - void Resolver_new::previsit( const ast::AggregateDecl * _aggDecl ) { + void Resolver::previsit( const ast::AggregateDecl * _aggDecl ) { auto aggDecl = mutate(_aggDecl); assertf(aggDecl == _aggDecl, "type declarations must be unique"); @@ -662,10 +662,10 @@ } - void Resolver_new::previsit( const ast::StructDecl * structDecl ) { + void Resolver::previsit( const ast::StructDecl * structDecl ) { previsit(static_cast(structDecl)); managedTypes.handleStruct(structDecl); } - void Resolver_new::previsit( const ast::EnumDecl * ) { + void Resolver::previsit( const ast::EnumDecl * ) { // in case we decide to allow nested enums GuardValue( inEnumDecl ); @@ -674,5 +674,5 @@ } - const ast::StaticAssertDecl * Resolver_new::previsit( + const ast::StaticAssertDecl * Resolver::previsit( const ast::StaticAssertDecl * assertDecl ) { @@ -694,13 +694,13 @@ } - const ast::ArrayType * Resolver_new::previsit( const ast::ArrayType * at ) { + const ast::ArrayType * Resolver::previsit( const ast::ArrayType * at ) { return handlePtrType( at, context ); } - const ast::PointerType * Resolver_new::previsit( const ast::PointerType * pt ) { + const ast::PointerType * Resolver::previsit( const ast::PointerType * pt ) { return handlePtrType( pt, context ); } - const ast::ExprStmt * Resolver_new::previsit( const ast::ExprStmt * exprStmt ) { + const ast::ExprStmt * Resolver::previsit( const ast::ExprStmt * exprStmt ) { visit_children = false; assertf( exprStmt->expr, "ExprStmt has null expression in resolver" ); @@ -710,5 +710,5 @@ } - const ast::AsmExpr * Resolver_new::previsit( const ast::AsmExpr * asmExpr ) { + const ast::AsmExpr * Resolver::previsit( const ast::AsmExpr * asmExpr ) { visit_children = false; @@ -719,5 +719,5 @@ } - const ast::AsmStmt * Resolver_new::previsit( const ast::AsmStmt * asmStmt ) { + const ast::AsmStmt * Resolver::previsit( const ast::AsmStmt * asmStmt ) { visitor->maybe_accept( asmStmt, &ast::AsmStmt::input ); visitor->maybe_accept( asmStmt, &ast::AsmStmt::output ); @@ -726,15 +726,15 @@ } - const ast::IfStmt * Resolver_new::previsit( const ast::IfStmt * ifStmt ) { + const ast::IfStmt * Resolver::previsit( const ast::IfStmt * ifStmt ) { return ast::mutate_field( ifStmt, &ast::IfStmt::cond, findIntegralExpression( ifStmt->cond, context ) ); } - const ast::WhileDoStmt * Resolver_new::previsit( const ast::WhileDoStmt * whileDoStmt ) { + const ast::WhileDoStmt * Resolver::previsit( const ast::WhileDoStmt * whileDoStmt ) { return ast::mutate_field( whileDoStmt, &ast::WhileDoStmt::cond, findIntegralExpression( whileDoStmt->cond, context ) ); } - const ast::ForStmt * Resolver_new::previsit( const ast::ForStmt * forStmt ) { + const ast::ForStmt * Resolver::previsit( const ast::ForStmt * forStmt ) { if ( forStmt->cond ) { forStmt = ast::mutate_field( @@ -750,5 +750,5 @@ } - const ast::SwitchStmt * Resolver_new::previsit( const ast::SwitchStmt * switchStmt ) { + const ast::SwitchStmt * Resolver::previsit( const ast::SwitchStmt * switchStmt ) { GuardValue( currentObject ); switchStmt = ast::mutate_field( @@ -759,5 +759,5 @@ } - const ast::CaseClause * Resolver_new::previsit( const ast::CaseClause * caseStmt ) { + const ast::CaseClause * Resolver::previsit( const ast::CaseClause * caseStmt ) { if ( caseStmt->cond ) { std::deque< ast::InitAlternative > initAlts = currentObject.getOptions(); @@ -780,5 +780,5 @@ } - const ast::BranchStmt * Resolver_new::previsit( const ast::BranchStmt * branchStmt ) { + const ast::BranchStmt * Resolver::previsit( const ast::BranchStmt * branchStmt ) { visit_children = false; // must resolve the argument of a computed goto @@ -793,5 +793,5 @@ } - const ast::ReturnStmt * Resolver_new::previsit( const ast::ReturnStmt * returnStmt ) { + const ast::ReturnStmt * Resolver::previsit( const ast::ReturnStmt * returnStmt ) { visit_children = false; if ( returnStmt->expr ) { @@ -803,5 +803,5 @@ } - const ast::ThrowStmt * Resolver_new::previsit( const ast::ThrowStmt * throwStmt ) { + const ast::ThrowStmt * Resolver::previsit( const ast::ThrowStmt * throwStmt ) { visit_children = false; if ( throwStmt->expr ) { @@ -818,5 +818,5 @@ } - const ast::CatchClause * Resolver_new::previsit( const ast::CatchClause * catchClause ) { + const ast::CatchClause * Resolver::previsit( const ast::CatchClause * catchClause ) { // Until we are very sure this invarent (ifs that move between passes have then) // holds, check it. This allows a check for when to decode the mangling. @@ -834,5 +834,5 @@ } - const ast::CatchClause * Resolver_new::postvisit( const ast::CatchClause * catchClause ) { + const ast::CatchClause * Resolver::postvisit( const ast::CatchClause * catchClause ) { // Decode the catchStmt so everything is stored properly. const ast::IfStmt * ifStmt = catchClause->body.as(); @@ -849,5 +849,5 @@ } - const ast::WaitForStmt * Resolver_new::previsit( const ast::WaitForStmt * stmt ) { + const ast::WaitForStmt * Resolver::previsit( const ast::WaitForStmt * stmt ) { visit_children = false; @@ -1114,5 +1114,5 @@ } - const ast::WithStmt * Resolver_new::previsit( const ast::WithStmt * withStmt ) { + const ast::WithStmt * Resolver::previsit( const ast::WithStmt * withStmt ) { auto mutStmt = mutate(withStmt); resolveWithExprs(mutStmt->exprs, stmtsToAddBefore); @@ -1120,5 +1120,5 @@ } - void Resolver_new::resolveWithExprs(std::vector> & exprs, std::list> & stmtsToAdd) { + void Resolver::resolveWithExprs(std::vector> & exprs, std::list> & stmtsToAdd) { for (auto & expr : exprs) { // only struct- and union-typed expressions are viable candidates @@ -1146,5 +1146,5 @@ - const ast::SingleInit * Resolver_new::previsit( const ast::SingleInit * singleInit ) { + const ast::SingleInit * Resolver::previsit( const ast::SingleInit * singleInit ) { visit_children = false; // resolve initialization using the possibilities as determined by the `currentObject` @@ -1195,5 +1195,5 @@ } - const ast::ListInit * Resolver_new::previsit( const ast::ListInit * listInit ) { + const ast::ListInit * Resolver::previsit( const ast::ListInit * listInit ) { // move cursor into brace-enclosed initializer-list currentObject.enterListInit( listInit->location ); @@ -1218,5 +1218,5 @@ } - const ast::ConstructorInit * Resolver_new::previsit( const ast::ConstructorInit * ctorInit ) { + const ast::ConstructorInit * Resolver::previsit( const ast::ConstructorInit * ctorInit ) { visitor->maybe_accept( ctorInit, &ast::ConstructorInit::ctor ); visitor->maybe_accept( ctorInit, &ast::ConstructorInit::dtor ); @@ -1240,5 +1240,5 @@ // suppress error on autogen functions and mark invalid autogen as deleted. - bool Resolver_new::on_error(ast::ptr & decl) { + bool Resolver::on_error(ast::ptr & decl) { if (auto functionDecl = decl.as()) { // xxx - can intrinsic gen ever fail? Index: src/ResolvExpr/Resolver.h =================================================================== --- src/ResolvExpr/Resolver.h (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/Resolver.h (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -16,17 +16,5 @@ #pragma once -#include // for list - #include "AST/Node.hpp" // for ptr - -class ConstructorInit; -class Declaration; -class Expression; -class DeletedExpr; -class StmtExpr; -class Type; -namespace SymTab { - class Indexer; -} // namespace SymTab namespace ast { @@ -45,17 +33,4 @@ namespace ResolvExpr { - /// Checks types and binds syntactic constructs to typed representations - void resolve( std::list< Declaration * > translationUnit ); - void resolveDecl( Declaration *, const SymTab::Indexer & indexer ); - Expression *resolveInVoidContext( Expression * expr, const SymTab::Indexer & indexer ); - void findVoidExpression( Expression *& untyped, const SymTab::Indexer & indexer ); - void findSingleExpression( Expression *& untyped, const SymTab::Indexer & indexer ); - void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer & indexer ); - void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer ); - void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer ); - /// Searches expr and returns the first DeletedExpr found, otherwise nullptr - DeletedExpr * findDeletedExpr( Expression * expr ); - /// Resolves with-stmts and with-clauses on functions - void resolveWithExprs( std::list< Declaration * > & translationUnit ); /// Helper Type: Passes around information between various sub-calls. Index: src/ResolvExpr/SpecCost.cc =================================================================== --- src/ResolvExpr/SpecCost.cc (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/SpecCost.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -76,5 +76,5 @@ public: - int get_count() const { return 0 <= count ? count : 0; } + int result() const { return 0 <= count ? count : 0; } // Mark specialization of base type. @@ -125,7 +125,5 @@ return 0; } - ast::Pass counter; - type->accept( counter ); - return counter.core.get_count(); + return ast::Pass::read( type ); } Index: src/ResolvExpr/Unify.cc =================================================================== --- src/ResolvExpr/Unify.cc (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/Unify.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -105,8 +105,8 @@ /// If this isn't done when satifying ttype assertions, then argument lists can have /// different size and structure when they should be compatible. - struct TtypeExpander_new : public ast::WithShortCircuiting, public ast::PureVisitor { + struct TtypeExpander : public ast::WithShortCircuiting, public ast::PureVisitor { ast::TypeEnvironment & tenv; - TtypeExpander_new( ast::TypeEnvironment & env ) : tenv( env ) {} + TtypeExpander( ast::TypeEnvironment & env ) : tenv( env ) {} const ast::Type * postvisit( const ast::TypeInstType * typeInst ) { @@ -128,5 +128,5 @@ dst.reserve( src.size() ); for ( const auto & d : src ) { - ast::Pass expander{ env }; + ast::Pass expander{ env }; // TtypeExpander pass is impure (may mutate nodes in place) // need to make nodes shared to prevent accidental mutation @@ -268,5 +268,5 @@ } - class Unify_new final : public ast::WithShortCircuiting { + class Unify final : public ast::WithShortCircuiting { const ast::Type * type2; ast::TypeEnvironment & tenv; @@ -279,5 +279,5 @@ bool result; - Unify_new( + Unify( const ast::Type * type2, ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open, WidenMode widen ) @@ -606,5 +606,5 @@ if ( ! tuple2 ) return; - ast::Pass expander{ tenv }; + ast::Pass expander{ tenv }; const ast::Type * flat = tuple->accept( expander ); @@ -634,5 +634,6 @@ }; - // size_t Unify_new::traceId = Stats::Heap::new_stacktrace_id("Unify_new"); + // size_t Unify::traceId = Stats::Heap::new_stacktrace_id("Unify"); + bool unify( const ast::ptr & type1, const ast::ptr & type2, @@ -678,5 +679,5 @@ return env.bindVar( var2, type1, ast::TypeData{var2->base}, need, have, open, widen ); } else { - return ast::Pass::read( + return ast::Pass::read( type1, type2, env, need, have, open, widen ); } Index: src/ResolvExpr/typeops.h =================================================================== --- src/ResolvExpr/typeops.h (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/ResolvExpr/typeops.h (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -19,8 +19,4 @@ #include "AST/Type.hpp" - -namespace SymTab { - class Indexer; -} namespace ResolvExpr { Index: src/SymTab/FixFunction.cc =================================================================== --- src/SymTab/FixFunction.cc (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/SymTab/FixFunction.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -26,5 +26,5 @@ namespace { - struct FixFunction_new final : public ast::WithShortCircuiting { + struct FixFunction final : public ast::WithShortCircuiting { bool isVoid = false; @@ -70,5 +70,5 @@ const ast::DeclWithType * fixFunction( const ast::DeclWithType * dwt, bool & isVoid ) { - ast::Pass< FixFunction_new > fixer; + ast::Pass< FixFunction > fixer; dwt = dwt->accept( fixer ); isVoid |= fixer.core.isVoid; @@ -77,5 +77,5 @@ const ast::Type * fixFunction( const ast::Type * type, bool & isVoid ) { - ast::Pass< FixFunction_new > fixer; + ast::Pass< FixFunction > fixer; type = type->accept( fixer ); isVoid |= fixer.core.isVoid; Index: src/SymTab/GenImplicitCall.cpp =================================================================== --- src/SymTab/GenImplicitCall.cpp (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/SymTab/GenImplicitCall.cpp (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -32,5 +32,5 @@ template< typename OutIter > ast::ptr< ast::Stmt > genCall( - InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, + InitTweak::InitExpander & srcParam, const ast::Expr * dstParam, const CodeLocation & loc, const std::string & fname, OutIter && out, const ast::Type * type, const ast::Type * addCast, LoopDirection forward = LoopForward ); @@ -42,5 +42,5 @@ template< typename OutIter > ast::ptr< ast::Stmt > genScalarCall( - InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, + InitTweak::InitExpander & srcParam, const ast::Expr * dstParam, const CodeLocation & loc, std::string fname, OutIter && out, const ast::Type * type, const ast::Type * addCast = nullptr @@ -98,5 +98,5 @@ template< typename OutIter > void genArrayCall( - InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, + InitTweak::InitExpander & srcParam, const ast::Expr * dstParam, const CodeLocation & loc, const std::string & fname, OutIter && out, const ast::ArrayType * array, const ast::Type * addCast = nullptr, @@ -167,5 +167,5 @@ template< typename OutIter > ast::ptr< ast::Stmt > genCall( - InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, + InitTweak::InitExpander & srcParam, const ast::Expr * dstParam, const CodeLocation & loc, const std::string & fname, OutIter && out, const ast::Type * type, const ast::Type * addCast, LoopDirection forward @@ -185,5 +185,5 @@ ast::ptr< ast::Stmt > genImplicitCall( - InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, + InitTweak::InitExpander & srcParam, const ast::Expr * dstParam, const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * obj, LoopDirection forward Index: src/SymTab/GenImplicitCall.hpp =================================================================== --- src/SymTab/GenImplicitCall.hpp (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/SymTab/GenImplicitCall.hpp (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -26,5 +26,5 @@ /// dstParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. ast::ptr genImplicitCall( - InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, + InitTweak::InitExpander & srcParam, const ast::Expr * dstParam, const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * obj, LoopDirection forward = LoopForward Index: src/SymTab/Mangler.cc =================================================================== --- src/SymTab/Mangler.cc (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/SymTab/Mangler.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -30,7 +30,7 @@ namespace { /// Mangles names to a unique C identifier - struct Mangler_new : public ast::WithShortCircuiting, public ast::WithVisitorRef, public ast::WithGuards { - Mangler_new( Mangle::Mode mode ); - Mangler_new( const Mangler_new & ) = delete; + struct Mangler : public ast::WithShortCircuiting, public ast::WithVisitorRef, public ast::WithGuards { + Mangler( Mangle::Mode mode ); + Mangler( const Mangler & ) = delete; void previsit( const ast::Node * ) { visit_children = false; } @@ -72,7 +72,7 @@ private: - Mangler_new( bool mangleOverridable, bool typeMode, bool mangleGenericParams, + Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams, int nextVarNum, const VarMapType& varNums ); - friend class ast::Pass; + friend class ast::Pass; private: @@ -81,13 +81,13 @@ void printQualifiers( const ast::Type *type ); - }; // Mangler_new + }; // Mangler } // namespace std::string mangle( const ast::Node * decl, Mangle::Mode mode ) { - return ast::Pass::read( decl, mode ); + return ast::Pass::read( decl, mode ); } namespace { - Mangler_new::Mangler_new( Mangle::Mode mode ) + Mangler::Mangler( Mangle::Mode mode ) : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable ( ! mode.no_overrideable ), @@ -95,5 +95,5 @@ mangleGenericParams( ! mode.no_generic_params ) {} - Mangler_new::Mangler_new( bool mangleOverridable, bool typeMode, bool mangleGenericParams, + Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams, int nextVarNum, const VarMapType& varNums ) : varNums( varNums ), nextVarNum( nextVarNum ), isTopLevel( false ), @@ -101,5 +101,5 @@ mangleGenericParams( mangleGenericParams ) {} - void Mangler_new::mangleDecl( const ast::DeclWithType * decl ) { + void Mangler::mangleDecl( const ast::DeclWithType * decl ) { bool wasTopLevel = isTopLevel; if ( isTopLevel ) { @@ -131,18 +131,18 @@ } - void Mangler_new::postvisit( const ast::ObjectDecl * decl ) { + void Mangler::postvisit( const ast::ObjectDecl * decl ) { mangleDecl( decl ); } - void Mangler_new::postvisit( const ast::FunctionDecl * decl ) { + void Mangler::postvisit( const ast::FunctionDecl * decl ) { mangleDecl( decl ); } - void Mangler_new::postvisit( const ast::VoidType * voidType ) { + void Mangler::postvisit( const ast::VoidType * voidType ) { printQualifiers( voidType ); mangleName += Encoding::void_t; } - void Mangler_new::postvisit( const ast::BasicType * basicType ) { + void Mangler::postvisit( const ast::BasicType * basicType ) { printQualifiers( basicType ); assertf( basicType->kind < ast::BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind ); @@ -150,5 +150,5 @@ } - void Mangler_new::postvisit( const ast::PointerType * pointerType ) { + void Mangler::postvisit( const ast::PointerType * pointerType ) { printQualifiers( pointerType ); // mangle void (*f)() and void f() to the same name to prevent overloading on functions and function pointers @@ -157,5 +157,5 @@ } - void Mangler_new::postvisit( const ast::ArrayType * arrayType ) { + void Mangler::postvisit( const ast::ArrayType * arrayType ) { // TODO: encode dimension printQualifiers( arrayType ); @@ -164,5 +164,5 @@ } - void Mangler_new::postvisit( const ast::ReferenceType * refType ) { + void Mangler::postvisit( const ast::ReferenceType * refType ) { // don't print prefix (e.g. 'R') for reference types so that references and non-references do not overload. // Further, do not print the qualifiers for a reference type (but do run printQualifers because of TypeDecls, etc.), @@ -174,5 +174,5 @@ } - void Mangler_new::postvisit( const ast::FunctionType * functionType ) { + void Mangler::postvisit( const ast::FunctionType * functionType ) { printQualifiers( functionType ); mangleName += Encoding::function; @@ -189,5 +189,5 @@ } - void Mangler_new::mangleRef( + void Mangler::mangleRef( const ast::BaseInstType * refType, const std::string & prefix ) { printQualifiers( refType ); @@ -206,17 +206,17 @@ } - void Mangler_new::postvisit( const ast::StructInstType * aggregateUseType ) { + void Mangler::postvisit( const ast::StructInstType * aggregateUseType ) { mangleRef( aggregateUseType, Encoding::struct_t ); } - void Mangler_new::postvisit( const ast::UnionInstType * aggregateUseType ) { + void Mangler::postvisit( const ast::UnionInstType * aggregateUseType ) { mangleRef( aggregateUseType, Encoding::union_t ); } - void Mangler_new::postvisit( const ast::EnumInstType * aggregateUseType ) { + void Mangler::postvisit( const ast::EnumInstType * aggregateUseType ) { mangleRef( aggregateUseType, Encoding::enum_t ); } - void Mangler_new::postvisit( const ast::TypeInstType * typeInst ) { + void Mangler::postvisit( const ast::TypeInstType * typeInst ) { VarMapType::iterator varNum = varNums.find( typeInst->name ); if ( varNum == varNums.end() ) { @@ -234,10 +234,10 @@ } - void Mangler_new::postvisit( const ast::TraitInstType * inst ) { + void Mangler::postvisit( const ast::TraitInstType * inst ) { printQualifiers( inst ); mangleName += std::to_string( inst->name.size() ) + inst->name; } - void Mangler_new::postvisit( const ast::TupleType * tupleType ) { + void Mangler::postvisit( const ast::TupleType * tupleType ) { printQualifiers( tupleType ); mangleName += Encoding::tuple + std::to_string( tupleType->types.size() ); @@ -245,5 +245,5 @@ } - void Mangler_new::postvisit( const ast::VarArgsType * varArgsType ) { + void Mangler::postvisit( const ast::VarArgsType * varArgsType ) { printQualifiers( varArgsType ); static const std::string vargs = "__builtin_va_list"; @@ -251,13 +251,13 @@ } - void Mangler_new::postvisit( const ast::ZeroType * ) { + void Mangler::postvisit( const ast::ZeroType * ) { mangleName += Encoding::zero; } - void Mangler_new::postvisit( const ast::OneType * ) { + void Mangler::postvisit( const ast::OneType * ) { mangleName += Encoding::one; } - void Mangler_new::postvisit( const ast::QualifiedType * qualType ) { + void Mangler::postvisit( const ast::QualifiedType * qualType ) { bool inqual = inQualifiedType; if ( !inqual ) { @@ -275,5 +275,5 @@ } - void Mangler_new::postvisit( const ast::TypeDecl * decl ) { + void Mangler::postvisit( const ast::TypeDecl * decl ) { // TODO: is there any case where mangling a TypeDecl makes sense? If so, this code needs to be // fixed to ensure that two TypeDecls mangle to the same name when they are the same type and vice versa. @@ -281,5 +281,5 @@ // and the case has not yet come up in practice. Alternatively, if not then this code can be removed // aside from the assert false. - assertf(false, "Mangler_new should not visit typedecl: %s", toCString(decl)); + assertf(false, "Mangler should not visit typedecl: %s", toCString(decl)); assertf( decl->kind < ast::TypeDecl::Kind::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind ); mangleName += Encoding::typeVariables[ decl->kind ] + std::to_string( decl->name.length() ) + decl->name; @@ -293,5 +293,5 @@ } - void Mangler_new::printQualifiers( const ast::Type * type ) { + void Mangler::printQualifiers( const ast::Type * type ) { // skip if not including qualifiers if ( typeMode ) return; @@ -318,5 +318,5 @@ } // for for ( auto & assert : funcType->assertions ) { - assertionNames.push_back( ast::Pass::read( + assertionNames.push_back( ast::Pass::read( assert->var.get(), mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums ) ); Index: src/Tuples/TupleAssignment.cc =================================================================== --- src/Tuples/TupleAssignment.cc (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/Tuples/TupleAssignment.cc (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -65,9 +65,9 @@ /// Dispatcher for tuple (multiple and mass) assignment operations - class TupleAssignSpotter_new final { + class TupleAssignSpotter final { /// Actually finds tuple assignment operations, by subclass struct Matcher { ResolvExpr::CandidateList lhs, rhs; - TupleAssignSpotter_new & spotter; + TupleAssignSpotter & spotter; CodeLocation location; ResolvExpr::Cost baseCost; @@ -84,5 +84,5 @@ Matcher( - TupleAssignSpotter_new & s, const CodeLocation & loc, + TupleAssignSpotter & s, const CodeLocation & loc, const ResolvExpr::CandidateList & l, const ResolvExpr::CandidateList & r ) : lhs( l ), rhs( r ), spotter( s ), location( loc ), @@ -161,5 +161,5 @@ struct MassAssignMatcher final : public Matcher { MassAssignMatcher( - TupleAssignSpotter_new & s, const CodeLocation & loc, + TupleAssignSpotter & s, const CodeLocation & loc, const ResolvExpr::CandidateList & l, const ResolvExpr::CandidateList & r ) : Matcher( s, loc, l, r ) {} @@ -191,5 +191,5 @@ struct MultipleAssignMatcher final : public Matcher { MultipleAssignMatcher( - TupleAssignSpotter_new & s, const CodeLocation & loc, + TupleAssignSpotter & s, const CodeLocation & loc, const ResolvExpr::CandidateList & l, const ResolvExpr::CandidateList & r ) : Matcher( s, loc, l, r ) {} @@ -240,5 +240,5 @@ public: - TupleAssignSpotter_new( ResolvExpr::CandidateFinder & f ) + TupleAssignSpotter( ResolvExpr::CandidateFinder & f ) : crntFinder( f ), fname(), matcher() {} @@ -377,5 +377,5 @@ std::vector< ResolvExpr::CandidateFinder > & args ) { - TupleAssignSpotter_new spotter{ finder }; + TupleAssignSpotter spotter{ finder }; spotter.spot( assign, args ); } Index: src/Validate/Autogen.cpp =================================================================== --- src/Validate/Autogen.cpp (revision 61efa421be36a355b304d2e9b9e14e493947d332) +++ src/Validate/Autogen.cpp (revision 6ea85b222eba7c3bf49507b5e21dd4709cee46e8) @@ -49,5 +49,5 @@ // -------------------------------------------------------------------------- -struct AutogenerateRoutines_new final : +struct AutogenerateRoutines final : public ast::WithDeclsToAdd<>, public ast::WithShortCircuiting { @@ -232,5 +232,5 @@ // -------------------------------------------------------------------------- -void AutogenerateRoutines_new::previsit( const ast::EnumDecl * enumDecl ) { +void AutogenerateRoutines::previsit( const ast::EnumDecl * enumDecl ) { // Must visit children (enum constants) to add them to the symbol table. if ( !enumDecl->body ) return; @@ -249,5 +249,5 @@ } -void AutogenerateRoutines_new::previsit( const ast::StructDecl * structDecl ) { +void AutogenerateRoutines::previsit( const ast::StructDecl * structDecl ) { visit_children = false; if ( !structDecl->body ) return; @@ -265,5 +265,5 @@ } -void AutogenerateRoutines_new::previsit( const ast::UnionDecl * unionDecl ) { +void AutogenerateRoutines::previsit( const ast::UnionDecl * unionDecl ) { visit_children = false; if ( !unionDecl->body ) return; @@ -282,5 +282,5 @@ /// Generate ctor/dtors/assign for typedecls, e.g., otype T = int *; -void AutogenerateRoutines_new::previsit( const ast::TypeDecl * typeDecl ) { +void AutogenerateRoutines::previsit( const ast::TypeDecl * typeDecl ) { if ( !typeDecl->base ) return; @@ -290,10 +290,10 @@ } -void AutogenerateRoutines_new::previsit( const ast::TraitDecl * ) { +void AutogenerateRoutines::previsit( const ast::TraitDecl * ) { // Ensure that we don't add assignment ops for types defined as part of the trait visit_children = false; } -void AutogenerateRoutines_new::previsit( const ast::FunctionDecl * ) { +void AutogenerateRoutines::previsit( const ast::FunctionDecl * ) { // Track whether we're currently in a function. // Can ignore function type idiosyncrasies, because function type can never @@ -302,5 +302,5 @@ } -void AutogenerateRoutines_new::postvisit( const ast::FunctionDecl * ) { +void AutogenerateRoutines::postvisit( const ast::FunctionDecl * ) { functionNesting -= 1; } @@ -521,5 +521,5 @@ const ast::Expr * src, const ast::ObjectDecl * field, ast::FunctionDecl * func, SymTab::LoopDirection direction ) { - InitTweak::InitExpander_new srcParam( src ); + InitTweak::InitExpander srcParam( src ); // Assign to destination. ast::MemberExpr * dstSelect = new ast::MemberExpr( @@ -795,5 +795,5 @@ void autogenerateRoutines( ast::TranslationUnit & translationUnit ) { - ast::Pass::run( translationUnit ); + ast::Pass::run( translationUnit ); }