Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/ResolvExpr/AlternativeFinder.cc

    r43bd69d r5af7306  
    2121#include <list>                    // for _List_iterator, list, _List_const_...
    2222#include <map>                     // for _Rb_tree_iterator, map, _Rb_tree_c...
    23 #include <memory>                  // for allocator_traits<>::value_type, unique_ptr
     23#include <memory>                  // for allocator_traits<>::value_type
    2424#include <utility>                 // for pair
    2525#include <vector>                  // for vector
    … …  
    3535#include "ResolveTypeof.h"         // for resolveTypeof
    3636#include "Resolver.h"              // for resolveStmtExpr
     37#include "Common/GC.h"             // for new_static_root
    3738#include "SymTab/Indexer.h"        // for Indexer
    3839#include "SymTab/Mangler.h"        // for Mangler
    … …  
    101102                void addAnonConversions( const Alternative & alt );
    102103                /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member
    103                 template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
     104                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string & name );
    104105                /// Adds alternatives for member expressions where the left side has tuple type
    105106                void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
    … …  
    165166                                        candidate->env.apply( newType );
    166167                                        mangleName = SymTab::Mangler::mangle( newType );
    167                                         delete newType;
    168168                                }
    169169                                std::map< std::string, PruneStruct >::iterator mapPlace = selected.find( mangleName );
    … …  
    297297                // adds anonymous member interpretations whenever an aggregate value type is seen.
    298298                // 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
    299                 std::unique_ptr<Expression> aggrExpr( alt.expr->clone() );
     299                Expression* aggrExpr = alt.expr->clone();
    300300                alt.env.apply( aggrExpr->get_result() );
    301301                Type * aggrType = aggrExpr->get_result();
    302302                if ( dynamic_cast< ReferenceType * >( aggrType ) ) {
    303303                        aggrType = aggrType->stripReferences();
    304                         aggrExpr.reset( new CastExpr( aggrExpr.release(), aggrType->clone() ) );
     304                        aggrExpr = new CastExpr{ aggrExpr, aggrType->clone() };
    305305                }
    306306
    307307                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) {
    308                         NameExpr nameExpr( "" );
    309                         addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
     308                        addAggMembers( structInst, aggrExpr, alt.cost+Cost::safe, alt.env, "" );
    310309                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) {
    311                         NameExpr nameExpr( "" );
    312                         addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
     310                        addAggMembers( unionInst, aggrExpr, alt.cost+Cost::safe, alt.env, "" );
    313311                } // if
    314312        }
    315313
    316314        template< typename StructOrUnionType >
    317         void AlternativeFinder::Finder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
    318                 // by this point, member must be a name expr
    319                 NameExpr * nameExpr = dynamic_cast< NameExpr * >( member );
    320                 if ( ! nameExpr ) return;
    321                 const std::string & name = nameExpr->get_name();
     315        void AlternativeFinder::Finder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string & name ) {
    322316                std::list< Declaration* > members;
    323317                aggInst->lookup( name, members );
    … …  
    459453        /// Adds type variables to the open variable set and marks their assertions
    460454        void makeUnifiableVars( Type *type, OpenVarSet &unifiableVars, AssertionSet &needAssertions ) {
    461                 for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) {
     455                for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
    462456                        unifiableVars[ (*tyvar)->get_name() ] = TypeDecl::Data{ *tyvar };
    463                         for ( std::list< DeclarationWithType* >::iterator assert = (*tyvar)->assertions.begin(); assert != (*tyvar)->assertions.end(); ++assert ) {
     457                        for ( std::list< DeclarationWithType* >::iterator assert = (*tyvar)->get_assertions().begin(); assert != (*tyvar)->get_assertions().end(); ++assert ) {
    464458                                needAssertions[ *assert ].isUsed = true;
    465459                        }
    … …  
    568562
    569563                                Expression *varExpr = data.combine( newerAlt.cvtCost );
    570                                 delete varExpr->get_result();
    571564                                varExpr->set_result( adjType->clone() );
    572565                                PRINT(
    … …  
    585578                                (*inferParameters)[ curDecl->get_uniqueId() ] = ParamEntry( candidate->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
    586579                                inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, /*newNeedParents,*/ level, indexer, out );
    587                         } else {
    588                                 delete adjType;
    589580                        }
    590581                }
    … …  
    634625        struct ArgPack {
    635626                std::size_t parent;                ///< Index of parent pack
    636                 std::unique_ptr<Expression> expr;  ///< The argument stored here
     627                Expression* expr;                  ///< The argument stored here
    637628                Cost cost;                         ///< The cost of this argument
    638629                TypeEnvironment env;               ///< Environment for this pack
    … …  
    681672                        std::list<Expression*> exprs;
    682673                        const ArgPack* pack = this;
    683                         if ( expr ) { exprs.push_front( expr.release() ); }
     674                        if ( expr ) { exprs.push_front( expr ); }
    684675                        while ( pack->tupleStart == 0 ) {
    685676                                pack = &packs[pack->parent];
    … …  
    688679                        }
    689680                        // reset pack to appropriate tuple
    690                         expr.reset( new TupleExpr( exprs ) );
     681                        expr = new TupleExpr{ exprs };
    691682                        tupleStart = pack->tupleStart - 1;
    692683                        parent = pack->parent;
    … …  
    740731
    741732                                                results.emplace_back(
    742                                                         i, expl.exprs[results[i].nextExpl].get(), copy(results[i].env),
     733                                                        i, expl.exprs[results[i].nextExpl], copy(results[i].env),
    743734                                                        copy(results[i].need), copy(results[i].have),
    744735                                                        copy(results[i].openVars), nextArg, nTuples, Cost::zero, nextExpl,
    … …  
    761752                                                        newResult.parent = i;
    762753                                                        std::list<Expression*> emptyList;
    763                                                         newResult.expr.reset( new TupleExpr( emptyList ) );
     754                                                        newResult.expr = new TupleExpr{ emptyList };
    764755                                                        argType = newResult.expr->get_result();
    765756                                                } else {
    … …  
    768759                                                        newResult.cost = results[i].cost;
    769760                                                        newResult.tupleStart = results[i].tupleStart;
    770                                                         newResult.expr.reset( results[i].expr->clone() );
     761                                                        newResult.expr = results[i].expr->clone();
    771762                                                        argType = newResult.expr->get_result();
    772763
    … …  
    818809                                                // add new result
    819810                                                results.emplace_back(
    820                                                         i, expl.exprs.front().get(), move(env), copy(results[i].need),
     811                                                        i, expl.exprs.front(), move(env), copy(results[i].need),
    821812                                                        copy(results[i].have), move(openVars), nextArg + 1,
    822813                                                        nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
    … …  
    844835                        if ( results[i].hasExpl() ) {
    845836                                const ExplodedActual& expl = results[i].getExpl( args );
    846                                 Expression* expr = expl.exprs[results[i].nextExpl].get();
     837                                Expression* expr = expl.exprs[results[i].nextExpl];
    847838
    848839                                TypeEnvironment env = results[i].env;
    … …  
    915906
    916907                                // consider only first exploded actual
    917                                 Expression* expr = expl.exprs.front().get();
     908                                Expression* expr = expl.exprs.front();
    918909                                Type* actualType = expr->get_result()->clone();
    919910
    … …  
    10181009
    10191010                                                results.emplace_back(
    1020                                                         i, expl.exprs[results[i].nextExpl].get(), copy(results[i].env),
     1011                                                        i, expl.exprs[results[i].nextExpl], copy(results[i].env),
    10211012                                                        copy(results[i].need), copy(results[i].have),
    10221013                                                        copy(results[i].openVars), nextArg, 0, Cost::zero, nextExpl,
    … …  
    10541045                                                // add new result
    10551046                                                results.emplace_back(
    1056                                                         i, expl.exprs.front().get(), move(env), copy(results[i].need),
     1047                                                        i, expl.exprs.front(), move(env), copy(results[i].need),
    10571048                                                        copy(results[i].have), move(openVars), nextArg + 1, 0,
    10581049                                                        expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
    … …  
    10881079
    10891080                // find function operators
    1090                 static NameExpr *opExpr = new NameExpr( "?()" );
     1081                static auto *opExpr = new_static_root<NameExpr>( "?()" );
    10911082                AlternativeFinder funcOpFinder( indexer, env );
    10921083                // it's ok if there aren't any defined function ops
    1093                 funcOpFinder.maybeFind( opExpr);
     1084                funcOpFinder.maybeFind( opExpr );
    10941085                PRINT(
    10951086                        std::cerr << "known function ops:" << std::endl;
    … …  
    12471238        }
    12481239
    1249         Expression * restructureCast( Expression * argExpr, Type * toType, bool isGenerated ) {
     1240        Expression * restructureCast( Expression * argExpr, Type * toType ) {
    12501241                if ( argExpr->get_result()->size() > 1 && ! toType->isVoid() && ! dynamic_cast<ReferenceType *>( toType ) ) {
    12511242                        // Argument expression is a tuple and the target type is not void and not a reference type.
    … …  
    12621253                                // cast each component
    12631254                                TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i );
    1264                                 componentExprs.push_back( restructureCast( idx, toType->getComponent( i ), isGenerated ) );
    1265                         }
    1266                         delete argExpr;
     1255                                componentExprs.push_back( restructureCast( idx, toType->getComponent( i ) ) );
     1256                        }
    12671257                        assert( componentExprs.size() > 0 );
    12681258                        // produce the tuple of casts
    … …  
    12701260                } else {
    12711261                        // handle normally
    1272                         CastExpr * ret = new CastExpr( argExpr, toType->clone() );
    1273                         ret->isGenerated = isGenerated;
    1274                         return ret;
     1262                        return new CastExpr( argExpr, toType->clone() );
    12751263                }
    12761264        }
    … …  
    13161304                                // count one safe conversion for each value that is thrown away
    13171305                                thisCost.incSafe( discardedValues );
    1318                                 Alternative newAlt( restructureCast( alt.expr->clone(), toType, castExpr->isGenerated ), alt.env,
     1306                                Alternative newAlt( restructureCast( alt.expr->clone(), toType ), alt.env,
    13191307                                        alt.cost, thisCost );
    13201308                                inferParameters( needAssertions, haveAssertions, newAlt, openVars,
    … …  
    13431331        }
    13441332
     1333        namespace {
     1334                /// Gets name from untyped member expression (member must be NameExpr)
     1335                const std::string& get_member_name( UntypedMemberExpr *memberExpr ) {
     1336                        NameExpr * nameExpr = dynamic_cast< NameExpr * >( memberExpr->get_member() );
     1337                        assert( nameExpr );
     1338                        return nameExpr->get_name();
     1339                }
     1340        }
     1341
    13451342        void AlternativeFinder::Finder::postvisit( UntypedMemberExpr *memberExpr ) {
    13461343                AlternativeFinder funcFinder( indexer, env );
    … …  
    13511348                        Expression * aggrExpr = agg->expr->clone();
    13521349                        referenceToRvalueConversion( aggrExpr, cost );
    1353                         std::unique_ptr<Expression> guard( aggrExpr );
    13541350
    13551351                        // find member of the given type
    13561352                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) {
    1357                                 addAggMembers( structInst, aggrExpr, cost, agg->env, memberExpr->get_member() );
     1353                                addAggMembers( structInst, aggrExpr, cost, agg->env, get_member_name(memberExpr) );
    13581354                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) {
    1359                                 addAggMembers( unionInst, aggrExpr, cost, agg->env, memberExpr->get_member() );
     1355                                addAggMembers( unionInst, aggrExpr, cost, agg->env, get_member_name(memberExpr) );
    13601356                        } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( aggrExpr->get_result() ) ) {
    13611357                                addTupleMembers( tupleType, aggrExpr, cost, agg->env, memberExpr->get_member() );
    … …  
    16021598                        alternatives.push_back( Alternative( new CommaExpr( newFirstArg->clone(), alt.expr->clone() ), alt.env, alt.cost ) );
    16031599                } // for
    1604                 delete newFirstArg;
    16051600        }
    16061601
    … …  
    17321727                                        // count one safe conversion for each value that is thrown away
    17331728                                        thisCost.incSafe( discardedValues );
    1734                                         Alternative newAlt( new InitExpr( restructureCast( alt.expr->clone(), toType, true ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost );
     1729                                        Alternative newAlt( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost );
    17351730                                        inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) );
    17361731                                }
Note: See TracChangeset for help on using the changeset viewer.