Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision 68f9c43ecf1873cbb5f06aee682704b56612ed16) +++ src/ResolvExpr/AlternativeFinder.cc (revision 8d7bef249652cc2b9854c7090c758bcd9ad9f613) @@ -21,5 +21,5 @@ #include // for _List_iterator, list, _List_const_... #include // for _Rb_tree_iterator, map, _Rb_tree_c... -#include // for allocator_traits<>::value_type, unique_ptr +#include // for allocator_traits<>::value_type #include // for pair #include // for vector @@ -296,18 +296,18 @@ // adds anonymous member interpretations whenever an aggregate value type is seen. // it's okay for the aggregate expression to have reference type -- cast it to the base type to treat the aggregate as the referenced value - std::unique_ptr aggrExpr( alt.expr->clone() ); + Expression* aggrExpr = alt.expr->clone(); alt.env.apply( aggrExpr->get_result() ); Type * aggrType = aggrExpr->get_result(); if ( dynamic_cast< ReferenceType * >( aggrType ) ) { aggrType = aggrType->stripReferences(); - aggrExpr.reset( new CastExpr( aggrExpr.release(), aggrType->clone() ) ); + aggrExpr = new CastExpr{ aggrExpr, aggrType->clone() }; } if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) { NameExpr nameExpr( "" ); - addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr ); + addAggMembers( structInst, aggrExpr, alt.cost+Cost::safe, alt.env, &nameExpr ); } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) { NameExpr nameExpr( "" ); - addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr ); + addAggMembers( unionInst, aggrExpr, alt.cost+Cost::safe, alt.env, &nameExpr ); } // if } @@ -630,5 +630,5 @@ struct ArgPack { std::size_t parent; ///< Index of parent pack - std::unique_ptr expr; ///< The argument stored here + Expression* expr; ///< The argument stored here Cost cost; ///< The cost of this argument TypeEnvironment env; ///< Environment for this pack @@ -677,5 +677,5 @@ std::list exprs; const ArgPack* pack = this; - if ( expr ) { exprs.push_front( expr.release() ); } + if ( expr ) { exprs.push_front( expr ); } while ( pack->tupleStart == 0 ) { pack = &packs[pack->parent]; @@ -684,5 +684,5 @@ } // reset pack to appropriate tuple - expr.reset( new TupleExpr( exprs ) ); + expr = new TupleExpr{ exprs }; tupleStart = pack->tupleStart - 1; parent = pack->parent; @@ -736,5 +736,5 @@ results.emplace_back( - i, expl.exprs[results[i].nextExpl].get(), copy(results[i].env), + i, expl.exprs[results[i].nextExpl], copy(results[i].env), copy(results[i].need), copy(results[i].have), copy(results[i].openVars), nextArg, nTuples, Cost::zero, nextExpl, @@ -757,5 +757,5 @@ newResult.parent = i; std::list emptyList; - newResult.expr.reset( new TupleExpr( emptyList ) ); + newResult.expr = new TupleExpr{ emptyList }; argType = newResult.expr->get_result(); } else { @@ -764,5 +764,5 @@ newResult.cost = results[i].cost; newResult.tupleStart = results[i].tupleStart; - newResult.expr.reset( results[i].expr->clone() ); + newResult.expr = results[i].expr->clone(); argType = newResult.expr->get_result(); @@ -814,5 +814,5 @@ // add new result results.emplace_back( - i, expl.exprs.front().get(), move(env), copy(results[i].need), + i, expl.exprs.front(), move(env), copy(results[i].need), copy(results[i].have), move(openVars), nextArg + 1, nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j ); @@ -840,5 +840,5 @@ if ( results[i].hasExpl() ) { const ExplodedActual& expl = results[i].getExpl( args ); - Expression* expr = expl.exprs[results[i].nextExpl].get(); + Expression* expr = expl.exprs[results[i].nextExpl]; TypeEnvironment env = results[i].env; @@ -911,5 +911,5 @@ // consider only first exploded actual - Expression* expr = expl.exprs.front().get(); + Expression* expr = expl.exprs.front(); Type* actualType = expr->get_result()->clone(); @@ -1014,5 +1014,5 @@ results.emplace_back( - i, expl.exprs[results[i].nextExpl].get(), copy(results[i].env), + i, expl.exprs[results[i].nextExpl], copy(results[i].env), copy(results[i].need), copy(results[i].have), copy(results[i].openVars), nextArg, 0, Cost::zero, nextExpl, @@ -1050,5 +1050,5 @@ // add new result results.emplace_back( - i, expl.exprs.front().get(), move(env), copy(results[i].need), + i, expl.exprs.front(), move(env), copy(results[i].need), copy(results[i].have), move(openVars), nextArg + 1, 0, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j ); @@ -1344,5 +1344,4 @@ Expression * aggrExpr = agg->expr->clone(); referenceToRvalueConversion( aggrExpr, cost ); - std::unique_ptr guard( aggrExpr ); // find member of the given type Index: src/ResolvExpr/ExplodedActual.h =================================================================== --- src/ResolvExpr/ExplodedActual.h (revision 68f9c43ecf1873cbb5f06aee682704b56612ed16) +++ src/ResolvExpr/ExplodedActual.h (revision 8d7bef249652cc2b9854c7090c758bcd9ad9f613) @@ -16,5 +16,4 @@ #pragma once -#include #include @@ -29,5 +28,5 @@ TypeEnvironment env; Cost cost; - std::vector< std::unique_ptr > exprs; + std::vector< Expression* > exprs; ExplodedActual() : env(), cost(Cost::zero), exprs() {} Index: src/ResolvExpr/Unify.cc =================================================================== --- src/ResolvExpr/Unify.cc (revision 68f9c43ecf1873cbb5f06aee682704b56612ed16) +++ src/ResolvExpr/Unify.cc (revision 8d7bef249652cc2b9854c7090c758bcd9ad9f613) @@ -17,5 +17,4 @@ #include // for back_insert_iterator, back_inserter #include // for _Rb_tree_const_iterator, _Rb_tree_i... -#include // for unique_ptr #include // for set #include // for string, operator==, operator!=, bas... @@ -165,7 +164,7 @@ Type *common = 0; // attempt to unify equivalence class type (which has qualifiers stripped, so they must be restored) with the type to bind to - std::unique_ptr< Type > newType( curClass.type->clone() ); + Type* newType = curClass.type->clone(); newType->get_qualifiers() = typeInst->get_qualifiers(); - if ( unifyInexact( newType.get(), other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass.allowWidening, true ), indexer, common ) ) { + if ( unifyInexact( newType, other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass.allowWidening, true ), indexer, common ) ) { if ( common ) { common->get_qualifiers() = Type::Qualifiers(); @@ -466,5 +465,5 @@ template< typename Iterator, typename Func > - std::unique_ptr combineTypes( Iterator begin, Iterator end, Func & toType ) { + Type* combineTypes( Iterator begin, Iterator end, Func & toType ) { std::list< Type * > types; for ( ; begin != end; ++begin ) { @@ -472,5 +471,5 @@ flatten( toType( *begin ), back_inserter( types ) ); } - return std::unique_ptr( new TupleType( Type::Qualifiers(), types ) ); + return new TupleType{ Type::Qualifiers(), types }; } @@ -487,8 +486,8 @@ if ( isTtype1 && ! isTtype2 ) { // combine all of the things in list2, then unify - return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); + return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); } else if ( isTtype2 && ! isTtype1 ) { // combine all of the things in list1, then unify - return unifyExact( combineTypes( list1Begin, list1End, get_type ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); + return unifyExact( combineTypes( list1Begin, list1End, get_type ), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); } else if ( ! unifyExact( t1, t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ) ) { return false; @@ -500,5 +499,5 @@ Type * t1 = (*list1Begin)->get_type(); if ( Tuples::isTtype( t1 ) ) { - return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); + return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); } else return false; } else if ( list2Begin != list2End ) { @@ -506,5 +505,5 @@ Type * t2 = (*list2Begin)->get_type(); if ( Tuples::isTtype( t2 ) ) { - return unifyExact( combineTypes( list1Begin, list1End, get_type ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); + return unifyExact( combineTypes( list1Begin, list1End, get_type ), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); } else return false; } else { @@ -559,6 +558,6 @@ // flatten the parameter lists for both functions so that tuple structure // doesn't affect unification. Must be a clone so that the types don't change. - std::unique_ptr flatFunc( functionType->clone() ); - std::unique_ptr flatOther( otherFunction->clone() ); + FunctionType* flatFunc = functionType->clone(); + FunctionType* flatOther = otherFunction->clone(); flattenList( flatFunc->get_parameters(), flatFunc->get_parameters(), env ); flattenList( flatOther->get_parameters(), flatOther->get_parameters(), env ); @@ -701,8 +700,8 @@ if ( isTtype1 && ! isTtype2 ) { // combine all of the things in list2, then unify - return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); + return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); } else if ( isTtype2 && ! isTtype1 ) { // combine all of the things in list1, then unify - return unifyExact( combineTypes( list1Begin, list1End, get_type ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); + return unifyExact( combineTypes( list1Begin, list1End, get_type ), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); } else if ( ! unifyExact( t1, t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ) ) { return false; @@ -714,5 +713,5 @@ Type * t1 = *list1Begin; if ( Tuples::isTtype( t1 ) ) { - return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); + return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); } else return false; } else if ( list2Begin != list2End ) { @@ -720,5 +719,5 @@ Type * t2 = *list2Begin; if ( Tuples::isTtype( t2 ) ) { - return unifyExact( combineTypes( list1Begin, list1End, get_type ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); + return unifyExact( combineTypes( list1Begin, list1End, get_type ), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); } else return false; } else { @@ -729,6 +728,6 @@ void Unify::postvisit(TupleType *tupleType) { if ( TupleType *otherTuple = dynamic_cast< TupleType* >( type2 ) ) { - std::unique_ptr flat1( tupleType->clone() ); - std::unique_ptr flat2( otherTuple->clone() ); + TupleType* flat1 = tupleType->clone(); + TupleType* flat2 = otherTuple->clone(); std::list types1, types2; @@ -737,6 +736,6 @@ flat2->acceptMutator( expander ); - flatten( flat1.get(), back_inserter( types1 ) ); - flatten( flat2.get(), back_inserter( types2 ) ); + flatten( flat1, back_inserter( types1 ) ); + flatten( flat2, back_inserter( types2 ) ); result = unifyList( types1.begin(), types1.end(), types2.begin(), types2.end(), env, needAssertions, haveAssertions, openVars, indexer );