Index: src/AST/Print.cpp =================================================================== --- src/AST/Print.cpp (revision 0fc91db1cac2084b1fb6e4b5d1e0fb31c7a12257) +++ src/AST/Print.cpp (revision 09f34a84d91d0f6c3dcd80079886a3a4dd8e7ec7) @@ -33,5 +33,5 @@ { return array{ - forward(values)... + std::forward(values)... }; } Index: src/AST/Type.cpp =================================================================== --- src/AST/Type.cpp (revision 0fc91db1cac2084b1fb6e4b5d1e0fb31c7a12257) +++ src/AST/Type.cpp (revision 09f34a84d91d0f6c3dcd80079886a3a4dd8e7ec7) @@ -143,5 +143,5 @@ TraitInstType::TraitInstType( const TraitDecl * b, CV::Qualifiers q, std::vector>&& as ) -: BaseInstType( b->name, q, move(as) ), base( b ) {} +: BaseInstType( b->name, q, std::move(as) ), base( b ) {} // --- TypeInstType @@ -149,5 +149,5 @@ TypeInstType::TypeInstType( const TypeDecl * b, CV::Qualifiers q, std::vector> && as ) -: BaseInstType( b->name, q, move(as) ), base( b ), kind( b->kind ) {} +: BaseInstType( b->name, q, std::move(as) ), base( b ), kind( b->kind ) {} void TypeInstType::set_base( const TypeDecl * b ) { @@ -161,5 +161,5 @@ TupleType::TupleType( std::vector> && ts, CV::Qualifiers q ) -: Type( q ), types( move(ts) ), members() { +: Type( q ), types( std::move(ts) ), members() { // This constructor is awkward. `TupleType` needs to contain objects so that members can be // named, but members without initializer nodes end up getting constructors, which breaks Index: src/Concurrency/Keywords.cc =================================================================== --- src/Concurrency/Keywords.cc (revision 0fc91db1cac2084b1fb6e4b5d1e0fb31c7a12257) +++ src/Concurrency/Keywords.cc (revision 09f34a84d91d0f6c3dcd80079886a3a4dd8e7ec7) @@ -508,5 +508,5 @@ ObjectDecl * vtable_object = Virtual::makeVtableForward( "_default_vtable_object_declaration", - vtable_decl->makeInst( move( poly_args ) ) ); + vtable_decl->makeInst( std::move( poly_args ) ) ); declsToAddBefore.push_back( vtable_object ); declsToAddBefore.push_back( @@ -681,5 +681,5 @@ void lock (monitor_t & this) { lock(get_monitor(this)); - } + } */ FunctionDecl * lock_decl = new FunctionDecl( @@ -700,5 +700,5 @@ CompoundStmt * lock_statement = new CompoundStmt(); lock_statement->push_back( - new ExprStmt( + new ExprStmt( new UntypedExpr ( new NameExpr( "lock" ), @@ -716,5 +716,5 @@ void unlock (monitor_t & this) { unlock(get_monitor(this)); - } + } */ FunctionDecl * unlock_decl = new FunctionDecl( @@ -736,5 +736,5 @@ unlock_statement->push_back( - new ExprStmt( + new ExprStmt( new UntypedExpr( new NameExpr( "unlock" ), @@ -746,5 +746,5 @@ ); unlock_decl->set_statements( unlock_statement ); - + // pushes routines to declsToAddAfter to add at a later time declsToAddAfter.push_back( lock_decl ); @@ -1054,5 +1054,5 @@ assert( !thread_guard_decl ); thread_guard_decl = decl; - } + } else if ( decl->name == "__mutex_stmt_lock_guard" && decl->body ) { assert( !lock_guard_decl ); @@ -1206,5 +1206,5 @@ new NameExpr( "__get_mutexstmt_lock_type" ), { args.front()->clone() } - ) + ) ) ), @@ -1225,10 +1225,10 @@ StructInstType * lock_guard_struct = new StructInstType( noQualifiers, lock_guard_decl ); - TypeExpr * lock_type_expr = new TypeExpr( + TypeExpr * lock_type_expr = new TypeExpr( new TypeofType( noQualifiers, new UntypedExpr( new NameExpr( "__get_mutexstmt_lock_type" ), { args.front()->clone() } - ) - ) + ) + ) ); Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 0fc91db1cac2084b1fb6e4b5d1e0fb31c7a12257) +++ src/Parser/parser.yy (revision 09f34a84d91d0f6c3dcd80079886a3a4dd8e7ec7) @@ -58,5 +58,7 @@ // lex uses __null in a boolean context, it's fine. -//#pragma GCC diagnostic ignored "-Wparentheses-equality" +#pragma GCC diagnostic ignored "-Wpragmas" +#pragma GCC diagnostic ignored "-Wparentheses-equality" +#pragma GCC diagnostic warning "-Wpragmas" extern DeclarationNode * parseTree; Index: src/ResolvExpr/CandidateFinder.cpp =================================================================== --- src/ResolvExpr/CandidateFinder.cpp (revision 0fc91db1cac2084b1fb6e4b5d1e0fb31c7a12257) +++ src/ResolvExpr/CandidateFinder.cpp (revision 09f34a84d91d0f6c3dcd80079886a3a4dd8e7ec7) @@ -269,6 +269,6 @@ unsigned nextArg, unsigned tupleStart = 0, Cost cost = Cost::zero, unsigned nextExpl = 0, unsigned explAlt = 0 ) - : parent(parent), expr( expr ), cost( cost ), env( move( env ) ), need( move( need ) ), - have( move( have ) ), open( move( open ) ), nextArg( nextArg ), tupleStart( tupleStart ), + : parent(parent), expr( expr ), cost( cost ), env( std::move( env ) ), need( std::move( need ) ), + have( std::move( have ) ), open( std::move( open ) ), nextArg( nextArg ), tupleStart( tupleStart ), nextExpl( nextExpl ), explAlt( explAlt ) {} @@ -276,6 +276,6 @@ const ArgPack & o, ast::TypeEnvironment && env, ast::AssertionSet && need, ast::AssertionSet && have, ast::OpenVarSet && open, unsigned nextArg, Cost added ) - : parent( o.parent ), expr( o.expr ), cost( o.cost + added ), env( move( env ) ), - need( move( need ) ), have( move( have ) ), open( move( open ) ), nextArg( nextArg ), + : parent( o.parent ), expr( o.expr ), cost( o.cost + added ), env( std::move( env ) ), + need( std::move( need ) ), have( std::move( have ) ), open( std::move( open ) ), nextArg( nextArg ), tupleStart( o.tupleStart ), nextExpl( 0 ), explAlt( 0 ) {} @@ -301,5 +301,5 @@ // reset pack to appropriate tuple std::vector< ast::ptr< ast::Expr > > exprv( exprs.begin(), exprs.end() ); - expr = new ast::TupleExpr{ expr->location, move( exprv ) }; + expr = new ast::TupleExpr{ expr->location, std::move( exprv ) }; tupleStart = pack->tupleStart - 1; parent = pack->parent; @@ -404,5 +404,5 @@ newResult.open, symtab ) ) { - finalResults.emplace_back( move( newResult ) ); + finalResults.emplace_back( std::move( newResult ) ); } @@ -423,6 +423,6 @@ if ( expl.exprs.empty() ) { results.emplace_back( - results[i], move( env ), copy( results[i].need ), - copy( results[i].have ), move( open ), nextArg + 1, expl.cost ); + results[i], std::move( env ), copy( results[i].need ), + copy( results[i].have ), std::move( open ), nextArg + 1, expl.cost ); continue; @@ -431,6 +431,6 @@ // add new result results.emplace_back( - i, expl.exprs.front(), move( env ), copy( results[i].need ), - copy( results[i].have ), move( open ), nextArg + 1, nTuples, + i, expl.exprs.front(), std::move( env ), copy( results[i].need ), + copy( results[i].have ), std::move( open ), nextArg + 1, nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j ); } @@ -444,5 +444,5 @@ // splice final results onto results for ( std::size_t i = 0; i < finalResults.size(); ++i ) { - results.emplace_back( move( finalResults[i] ) ); + results.emplace_back( std::move( finalResults[i] ) ); } return ! finalResults.empty(); @@ -478,5 +478,5 @@ results.emplace_back( - i, expr, move( env ), move( need ), move( have ), move( open ), nextArg, + i, expr, std::move( env ), std::move( need ), std::move( have ), std::move( open ), nextArg, nTuples, Cost::zero, nextExpl, results[i].explAlt ); } @@ -494,6 +494,6 @@ if ( unify( paramType, cnst->result, env, need, have, open, symtab ) ) { results.emplace_back( - i, new ast::DefaultArgExpr{ cnst->location, cnst }, move( env ), - move( need ), move( have ), move( open ), nextArg, nTuples ); + i, new ast::DefaultArgExpr{ cnst->location, cnst }, std::move( env ), + std::move( need ), std::move( have ), std::move( open ), nextArg, nTuples ); } } @@ -516,5 +516,5 @@ if ( expl.exprs.empty() ) { results.emplace_back( - results[i], move( env ), move( need ), move( have ), move( open ), + results[i], std::move( env ), std::move( need ), std::move( have ), std::move( open ), nextArg + 1, expl.cost ); @@ -538,5 +538,5 @@ // add new result results.emplace_back( - i, expr, move( env ), move( need ), move( have ), move( open ), + i, expr, std::move( env ), std::move( need ), std::move( have ), std::move( open ), nextArg + 1, nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j ); } @@ -576,5 +576,5 @@ restructureCast( idx, toType->getComponent( i ), isGenerated ) ); } - return new ast::TupleExpr{ arg->location, move( components ) }; + return new ast::TupleExpr{ arg->location, std::move( components ) }; } else { // handle normally @@ -672,5 +672,5 @@ } std::vector< ast::ptr< ast::Expr > > vargs( args.begin(), args.end() ); - appExpr->args = move( vargs ); + appExpr->args = std::move( vargs ); // build and validate new candidate auto newCand = @@ -783,6 +783,6 @@ if ( expl.exprs.empty() ) { results.emplace_back( - results[i], move( env ), copy( results[i].need ), - copy( results[i].have ), move( open ), nextArg + 1, + results[i], std::move( env ), copy( results[i].need ), + copy( results[i].have ), std::move( open ), nextArg + 1, expl.cost ); @@ -792,6 +792,6 @@ // add new result results.emplace_back( - i, expl.exprs.front(), move( env ), copy( results[i].need ), - copy( results[i].have ), move( open ), nextArg + 1, 0, expl.cost, + i, expl.exprs.front(), std::move( env ), copy( results[i].need ), + copy( results[i].have ), std::move( open ), nextArg + 1, 0, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j ); } @@ -843,5 +843,5 @@ // as a member expression addAnonConversions( newCand ); - candidates.emplace_back( move( newCand ) ); + candidates.emplace_back( std::move( newCand ) ); } } @@ -901,5 +901,5 @@ const ast::EnumDecl * enumDecl = enumInst->base; if ( const ast::Type* enumType = enumDecl->base ) { - // instance of enum (T) is a instance of type (T) + // instance of enum (T) is a instance of type (T) funcFinder.otypeKeys.insert(Mangle::mangle(enumType, Mangle::NoGenericParams | Mangle::Type)); } else { @@ -907,5 +907,5 @@ funcFinder.otypeKeys.insert(Mangle::mangle(enumDecl, Mangle::NoGenericParams | Mangle::Type)); } - } + } else funcFinder.otypeKeys.insert(Mangle::mangle(argType, Mangle::NoGenericParams | Mangle::Type)); } @@ -986,5 +986,5 @@ funcE.emplace_back( *func, symtab ); } - argExpansions.emplace_front( move( funcE ) ); + argExpansions.emplace_front( std::move( funcE ) ); for ( const CandidateRef & op : opFinder ) { @@ -1030,8 +1030,8 @@ if ( cvtCost != Cost::infinity ) { withFunc->cvtCost = cvtCost; - candidates.emplace_back( move( withFunc ) ); - } - } - found = move( candidates ); + candidates.emplace_back( std::move( withFunc ) ); + } + } + found = std::move( candidates ); // use a new list so that candidates are not examined by addAnonConversions twice @@ -1131,5 +1131,5 @@ CandidateRef newCand = std::make_shared( restructureCast( cand->expr, toType, castExpr->isGenerated ), - copy( cand->env ), move( open ), move( need ), cand->cost, + copy( cand->env ), std::move( open ), std::move( need ), cand->cost, cand->cost + thisCost ); inferParameters( newCand, matches ); @@ -1285,5 +1285,5 @@ // as a name expression addAnonConversions( newCand ); - candidates.emplace_back( move( newCand ) ); + candidates.emplace_back( std::move( newCand ) ); } } @@ -1394,5 +1394,5 @@ new ast::LogicalExpr{ logicalExpr->location, r1->expr, r2->expr, logicalExpr->isAnd }, - move( env ), move( open ), move( need ), r1->cost + r2->cost ); + std::move( env ), std::move( open ), std::move( need ), r1->cost + r2->cost ); } } @@ -1452,5 +1452,5 @@ // output candidate CandidateRef newCand = std::make_shared( - newExpr, move( env ), move( open ), move( need ), cost ); + newExpr, std::move( env ), std::move( open ), std::move( need ), cost ); inferParameters( newCand, candidates ); } @@ -1519,5 +1519,5 @@ // add candidate CandidateRef newCand = std::make_shared( - newExpr, move( env ), move( open ), move( need ), + newExpr, std::move( env ), std::move( open ), std::move( need ), r1->cost + r2->cost ); inferParameters( newCand, candidates ); @@ -1548,6 +1548,6 @@ addCandidate( - new ast::TupleExpr{ tupleExpr->location, move( exprs ) }, - move( env ), move( open ), move( need ), sumCost( subs ) ); + new ast::TupleExpr{ tupleExpr->location, std::move( exprs ) }, + std::move( env ), std::move( open ), std::move( need ), sumCost( subs ) ); } } @@ -1635,5 +1635,5 @@ initExpr->location, restructureCast( cand->expr, toType ), initAlt.designation }, - move(env), move( open ), move( need ), cand->cost, thisCost ); + std::move(env), std::move( open ), std::move( need ), cand->cost, thisCost ); inferParameters( newCand, matches ); } @@ -1768,5 +1768,5 @@ cand->env.applyFree( newResult ); cand->expr = ast::mutate_field( - cand->expr.get(), &ast::Expr::result, move( newResult ) ); + cand->expr.get(), &ast::Expr::result, std::move( newResult ) ); out.emplace_back( cand ); @@ -1854,5 +1854,5 @@ auto oldsize = candidates.size(); - candidates = move( pruned ); + candidates = std::move( pruned ); PRINT( Index: src/main.cc =================================================================== --- src/main.cc (revision 0fc91db1cac2084b1fb6e4b5d1e0fb31c7a12257) +++ src/main.cc (revision 09f34a84d91d0f6c3dcd80079886a3a4dd8e7ec7) @@ -325,5 +325,5 @@ ast::pass_visitor_stats.max = Stats::Counters::build>("Max depth - New"); } - auto transUnit = convert( move( translationUnit ) ); + auto transUnit = convert( std::move( translationUnit ) ); forceFillCodeLocations( transUnit ); @@ -331,5 +331,5 @@ PASS( "Translate Exception Declarations", ControlStruct::translateExcept( transUnit ) ); if ( exdeclp ) { - dump( move( transUnit ) ); + dump( std::move( transUnit ) ); return EXIT_SUCCESS; } @@ -378,5 +378,5 @@ if ( validp ) { - dump( move( transUnit ) ); + dump( std::move( transUnit ) ); return EXIT_SUCCESS; } // if @@ -399,5 +399,5 @@ if ( bresolvep ) { - dump( move( transUnit ) ); + dump( std::move( transUnit ) ); return EXIT_SUCCESS; } // if @@ -410,5 +410,5 @@ PASS( "Resolve", ResolvExpr::resolve( transUnit ) ); if ( exprp ) { - dump( move( transUnit ) ); + dump( std::move( transUnit ) ); return EXIT_SUCCESS; } // if @@ -420,5 +420,5 @@ // fix ObjectDecl - replaces ConstructorInit nodes if ( ctorinitp ) { - dump( move( transUnit ) ); + dump( std::move( transUnit ) ); return EXIT_SUCCESS; } // if @@ -436,5 +436,5 @@ if ( tuplep ) { - dump( move( transUnit ) ); + dump( std::move( transUnit ) ); return EXIT_SUCCESS; } // if @@ -445,5 +445,5 @@ PASS( "Instantiate Generics", GenPoly::instantiateGeneric( transUnit ) ); - translationUnit = convert( move( transUnit ) ); + translationUnit = convert( std::move( transUnit ) ); if ( genericsp ) { @@ -788,5 +788,5 @@ static void dump( ast::TranslationUnit && transUnit, ostream & out ) { - std::list< Declaration * > translationUnit = convert( move( transUnit ) ); + std::list< Declaration * > translationUnit = convert( std::move( transUnit ) ); dump( translationUnit, out ); }