Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/ResolvExpr/AlternativeFinder.cc

    r5af7306 r43bd69d  
    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
     23#include <memory>                  // for allocator_traits<>::value_type, unique_ptr
    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
    3837#include "SymTab/Indexer.h"        // for Indexer
    3938#include "SymTab/Mangler.h"        // for Mangler
    … …  
    102101                void addAnonConversions( const Alternative & alt );
    103102                /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member
    104                 template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string & name );
     103                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
    105104                /// Adds alternatives for member expressions where the left side has tuple type
    106105                void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
    … …  
    166165                                        candidate->env.apply( newType );
    167166                                        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                 Expression* aggrExpr = alt.expr->clone();
     299                std::unique_ptr<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 = new CastExpr{ aggrExpr, aggrType->clone() };
     304                        aggrExpr.reset( new CastExpr( aggrExpr.release(), aggrType->clone() ) );
    305305                }
    306306
    307307                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) {
    308                         addAggMembers( structInst, aggrExpr, alt.cost+Cost::safe, alt.env, "" );
     308                        NameExpr nameExpr( "" );
     309                        addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
    309310                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) {
    310                         addAggMembers( unionInst, aggrExpr, alt.cost+Cost::safe, alt.env, "" );
     311                        NameExpr nameExpr( "" );
     312                        addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
    311313                } // if
    312314        }
    313315
    314316        template< typename StructOrUnionType >
    315         void AlternativeFinder::Finder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string & name ) {
     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();
    316322                std::list< Declaration* > members;
    317323                aggInst->lookup( name, members );
    … …  
    453459        /// Adds type variables to the open variable set and marks their assertions
    454460        void makeUnifiableVars( Type *type, OpenVarSet &unifiableVars, AssertionSet &needAssertions ) {
    455                 for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
     461                for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) {
    456462                        unifiableVars[ (*tyvar)->get_name() ] = TypeDecl::Data{ *tyvar };
    457                         for ( std::list< DeclarationWithType* >::iterator assert = (*tyvar)->get_assertions().begin(); assert != (*tyvar)->get_assertions().end(); ++assert ) {
     463                        for ( std::list< DeclarationWithType* >::iterator assert = (*tyvar)->assertions.begin(); assert != (*tyvar)->assertions.end(); ++assert ) {
    458464                                needAssertions[ *assert ].isUsed = true;
    459465                        }
    … …  
    562568
    563569                                Expression *varExpr = data.combine( newerAlt.cvtCost );
     570                                delete varExpr->get_result();
    564571                                varExpr->set_result( adjType->clone() );
    565572                                PRINT(
    … …  
    578585                                (*inferParameters)[ curDecl->get_uniqueId() ] = ParamEntry( candidate->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
    579586                                inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, /*newNeedParents,*/ level, indexer, out );
     587                        } else {
     588                                delete adjType;
    580589                        }
    581590                }
    … …  
    625634        struct ArgPack {
    626635                std::size_t parent;                ///< Index of parent pack
    627                 Expression* expr;                  ///< The argument stored here
     636                std::unique_ptr<Expression> expr;  ///< The argument stored here
    628637                Cost cost;                         ///< The cost of this argument
    629638                TypeEnvironment env;               ///< Environment for this pack
    … …  
    672681                        std::list<Expression*> exprs;
    673682                        const ArgPack* pack = this;
    674                         if ( expr ) { exprs.push_front( expr ); }
     683                        if ( expr ) { exprs.push_front( expr.release() ); }
    675684                        while ( pack->tupleStart == 0 ) {
    676685                                pack = &packs[pack->parent];
    … …  
    679688                        }
    680689                        // reset pack to appropriate tuple
    681                         expr = new TupleExpr{ exprs };
     690                        expr.reset( new TupleExpr( exprs ) );
    682691                        tupleStart = pack->tupleStart - 1;
    683692                        parent = pack->parent;
    … …  
    731740
    732741                                                results.emplace_back(
    733                                                         i, expl.exprs[results[i].nextExpl], copy(results[i].env),
     742                                                        i, expl.exprs[results[i].nextExpl].get(), copy(results[i].env),
    734743                                                        copy(results[i].need), copy(results[i].have),
    735744                                                        copy(results[i].openVars), nextArg, nTuples, Cost::zero, nextExpl,
    … …  
    752761                                                        newResult.parent = i;
    753762                                                        std::list<Expression*> emptyList;
    754                                                         newResult.expr = new TupleExpr{ emptyList };
     763                                                        newResult.expr.reset( new TupleExpr( emptyList ) );
    755764                                                        argType = newResult.expr->get_result();
    756765                                                } else {
    … …  
    759768                                                        newResult.cost = results[i].cost;
    760769                                                        newResult.tupleStart = results[i].tupleStart;
    761                                                         newResult.expr = results[i].expr->clone();
     770                                                        newResult.expr.reset( results[i].expr->clone() );
    762771                                                        argType = newResult.expr->get_result();
    763772
    … …  
    809818                                                // add new result
    810819                                                results.emplace_back(
    811                                                         i, expl.exprs.front(), move(env), copy(results[i].need),
     820                                                        i, expl.exprs.front().get(), move(env), copy(results[i].need),
    812821                                                        copy(results[i].have), move(openVars), nextArg + 1,
    813822                                                        nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
    … …  
    835844                        if ( results[i].hasExpl() ) {
    836845                                const ExplodedActual& expl = results[i].getExpl( args );
    837                                 Expression* expr = expl.exprs[results[i].nextExpl];
     846                                Expression* expr = expl.exprs[results[i].nextExpl].get();
    838847
    839848                                TypeEnvironment env = results[i].env;
    … …  
    906915
    907916                                // consider only first exploded actual
    908                                 Expression* expr = expl.exprs.front();
     917                                Expression* expr = expl.exprs.front().get();
    909918                                Type* actualType = expr->get_result()->clone();
    910919
    … …  
    10091018
    10101019                                                results.emplace_back(
    1011                                                         i, expl.exprs[results[i].nextExpl], copy(results[i].env),
     1020                                                        i, expl.exprs[results[i].nextExpl].get(), copy(results[i].env),
    10121021                                                        copy(results[i].need), copy(results[i].have),
    10131022                                                        copy(results[i].openVars), nextArg, 0, Cost::zero, nextExpl,
    … …  
    10451054                                                // add new result
    10461055                                                results.emplace_back(
    1047                                                         i, expl.exprs.front(), move(env), copy(results[i].need),
     1056                                                        i, expl.exprs.front().get(), move(env), copy(results[i].need),
    10481057                                                        copy(results[i].have), move(openVars), nextArg + 1, 0,
    10491058                                                        expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
    … …  
    10791088
    10801089                // find function operators
    1081                 static auto *opExpr = new_static_root<NameExpr>( "?()" );
     1090                static NameExpr *opExpr = new NameExpr( "?()" );
    10821091                AlternativeFinder funcOpFinder( indexer, env );
    10831092                // it's ok if there aren't any defined function ops
    1084                 funcOpFinder.maybeFind( opExpr );
     1093                funcOpFinder.maybeFind( opExpr);
    10851094                PRINT(
    10861095                        std::cerr << "known function ops:" << std::endl;
    … …  
    12381247        }
    12391248
    1240         Expression * restructureCast( Expression * argExpr, Type * toType ) {
     1249        Expression * restructureCast( Expression * argExpr, Type * toType, bool isGenerated ) {
    12411250                if ( argExpr->get_result()->size() > 1 && ! toType->isVoid() && ! dynamic_cast<ReferenceType *>( toType ) ) {
    12421251                        // Argument expression is a tuple and the target type is not void and not a reference type.
    … …  
    12531262                                // cast each component
    12541263                                TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i );
    1255                                 componentExprs.push_back( restructureCast( idx, toType->getComponent( i ) ) );
    1256                         }
     1264                                componentExprs.push_back( restructureCast( idx, toType->getComponent( i ), isGenerated ) );
     1265                        }
     1266                        delete argExpr;
    12571267                        assert( componentExprs.size() > 0 );
    12581268                        // produce the tuple of casts
    … …  
    12601270                } else {
    12611271                        // handle normally
    1262                         return new CastExpr( argExpr, toType->clone() );
     1272                        CastExpr * ret = new CastExpr( argExpr, toType->clone() );
     1273                        ret->isGenerated = isGenerated;
     1274                        return ret;
    12631275                }
    12641276        }
    … …  
    13041316                                // count one safe conversion for each value that is thrown away
    13051317                                thisCost.incSafe( discardedValues );
    1306                                 Alternative newAlt( restructureCast( alt.expr->clone(), toType ), alt.env,
     1318                                Alternative newAlt( restructureCast( alt.expr->clone(), toType, castExpr->isGenerated ), alt.env,
    13071319                                        alt.cost, thisCost );
    13081320                                inferParameters( needAssertions, haveAssertions, newAlt, openVars,
    … …  
    13311343        }
    13321344
    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 
    13421345        void AlternativeFinder::Finder::postvisit( UntypedMemberExpr *memberExpr ) {
    13431346                AlternativeFinder funcFinder( indexer, env );
    … …  
    13481351                        Expression * aggrExpr = agg->expr->clone();
    13491352                        referenceToRvalueConversion( aggrExpr, cost );
     1353                        std::unique_ptr<Expression> guard( aggrExpr );
    13501354
    13511355                        // find member of the given type
    13521356                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) {
    1353                                 addAggMembers( structInst, aggrExpr, cost, agg->env, get_member_name(memberExpr) );
     1357                                addAggMembers( structInst, aggrExpr, cost, agg->env, memberExpr->get_member() );
    13541358                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) {
    1355                                 addAggMembers( unionInst, aggrExpr, cost, agg->env, get_member_name(memberExpr) );
     1359                                addAggMembers( unionInst, aggrExpr, cost, agg->env, memberExpr->get_member() );
    13561360                        } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( aggrExpr->get_result() ) ) {
    13571361                                addTupleMembers( tupleType, aggrExpr, cost, agg->env, memberExpr->get_member() );
    … …  
    15981602                        alternatives.push_back( Alternative( new CommaExpr( newFirstArg->clone(), alt.expr->clone() ), alt.env, alt.cost ) );
    15991603                } // for
     1604                delete newFirstArg;
    16001605        }
    16011606
    … …  
    17271732                                        // count one safe conversion for each value that is thrown away
    17281733                                        thisCost.incSafe( discardedValues );
    1729                                         Alternative newAlt( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost );
     1734                                        Alternative newAlt( new InitExpr( restructureCast( alt.expr->clone(), toType, true ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost );
    17301735                                        inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) );
    17311736                                }
Note: See TracChangeset for help on using the changeset viewer.