Changeset 62194cb


Ignore:
Timestamp:
Nov 23, 2017, 4:24:48 PM (4 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
178e4ec
Parents:
a8b27c6
Message:

Reduce duplication of cost/env in ExplodedActual?

Location:
src
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • src/ResolvExpr/Alternative.h

    ra8b27c6 r62194cb  
    3737                void print( std::ostream &os, Indenter indent = {} ) const;
    3838
     39                /// Returns the stored expression, but released from management of this Alternative
     40                Expression* release_expr() {
     41                        Expression* tmp = expr;
     42                        expr = nullptr;
     43                        return tmp;
     44                }
     45
    3946                Cost cost;
    4047                Cost cvtCost;
  • src/ResolvExpr/AlternativeFinder.cc

    ra8b27c6 r62194cb  
    676676                                        auto nextArg = results[i].nextArg;
    677677
    678                                         // use remainder of exploded tuple if present
     678                                        // use next element of exploded tuple if present
    679679                                        if ( results[i].hasExpl() ) {
    680680                                                const ExplodedActual& expl = results[i].getExpl( args );
    681                                                 const Alternative& actual = expl.alts[results[i].nextExpl];
    682681                                               
    683                                                 TypeEnvironment env = results[i].env;
    684                                                 OpenVarSet openVars = results[i].openVars;
    685 
    686                                                 env.addActual( actual.env, openVars );
    687 
    688682                                                unsigned nextExpl = results[i].nextExpl + 1;
    689                                                 if ( nextExpl == expl.alts.size() ) {
     683                                                if ( nextExpl == expl.exprs.size() ) {
    690684                                                        nextExpl = 0;
    691685                                                }
    692686
    693687                                                results.emplace_back(
    694                                                         i, actual.expr, move(env), copy(results[i].need),
    695                                                         copy(results[i].have), move(openVars), nextArg, nTuples,
    696                                                         Cost::zero, nextExpl, results[i].explAlt );
     688                                                        i, expl.exprs[results[i].nextExpl].get(), copy(results[i].env),
     689                                                        copy(results[i].need), copy(results[i].have),
     690                                                        copy(results[i].openVars), nextArg, nTuples, Cost::zero, nextExpl,
     691                                                        results[i].explAlt );
    697692                                               
    698693                                                continue;
     
    758753
    759754                                                // skip empty tuple arguments by (near-)cloning parent into next gen
    760                                                 if ( expl.alts.empty() ) {
     755                                                if ( expl.exprs.empty() ) {
    761756                                                        results.emplace_back(
    762757                                                                results[i], move(env), copy(results[i].need),
     
    768763                                                // add new result
    769764                                                results.emplace_back(
    770                                                         i, expl.alts.front().expr, move(env), copy(results[i].need),
     765                                                        i, expl.exprs.front().get(), move(env), copy(results[i].need),
    771766                                                        copy(results[i].have), move(openVars), nextArg + 1,
    772                                                         nTuples, expl.cost, expl.alts.size() == 1 ? 0 : 1, j );
     767                                                        nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
    773768                                        }
    774769                                }
     
    794789                        if ( results[i].hasExpl() ) {
    795790                                const ExplodedActual& expl = results[i].getExpl( args );
    796                                 const Alternative& actual = expl.alts[results[i].nextExpl];
     791                                Expression* expr = expl.exprs[results[i].nextExpl].get();
    797792                               
    798793                                TypeEnvironment env = results[i].env;
     
    800795                                OpenVarSet openVars = results[i].openVars;
    801796
    802                                 env.addActual( actual.env, openVars );
    803                                 Type* actualType = actual.expr->get_result();
     797                                Type* actualType = expr->get_result();
    804798
    805799                                PRINT(
     
    813807                                if ( unify( formalType, actualType, env, need, have, openVars, indexer ) ) {
    814808                                        unsigned nextExpl = results[i].nextExpl + 1;
    815                                         if ( nextExpl == expl.alts.size() ) {
     809                                        if ( nextExpl == expl.exprs.size() ) {
    816810                                                nextExpl = 0;
    817811                                        }
    818812                                       
    819813                                        results.emplace_back(
    820                                                 i, actual.expr, move(env), move(need), move(have), move(openVars),
    821                                                 nextArg, nTuples, Cost::zero, nextExpl, results[i].explAlt );
     814                                                i, expr, move(env), move(need), move(have), move(openVars), nextArg,
     815                                                nTuples, Cost::zero, nextExpl, results[i].explAlt );
    822816                                }
    823817
     
    857851                               
    858852                                // skip empty tuple arguments by (near-)cloning parent into next gen
    859                                 if ( expl.alts.empty() ) {
     853                                if ( expl.exprs.empty() ) {
    860854                                        results.emplace_back(
    861855                                                results[i], move(env), move(need), move(have), move(openVars),
     
    866860
    867861                                // consider only first exploded actual
    868                                 const Alternative& actual = expl.alts.front();
    869                                 Type* actualType = actual.expr->get_result()->clone();
     862                                Expression* expr = expl.exprs.front().get();
     863                                Type* actualType = expr->get_result()->clone();
    870864
    871865                                PRINT(
     
    881875                                        // add new result
    882876                                        results.emplace_back(
    883                                                 i, actual.expr, move(env), move(need), move(have), move(openVars),
    884                                                 nextArg + 1, nTuples, expl.cost, expl.alts.size() == 1 ? 0 : 1, j );
     877                                                i, expr, move(env), move(need), move(have), move(openVars), nextArg + 1,
     878                                                nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
    885879                                }
    886880                        }
     
    962956                                        if ( results[i].hasExpl() ) {
    963957                                                const ExplodedActual& expl = results[i].getExpl( args );
    964                                                 const Alternative& actual = expl.alts[results[i].nextExpl];
    965958                                               
    966                                                 TypeEnvironment env = results[i].env;
    967                                                 OpenVarSet openVars = results[i].openVars;
    968 
    969                                                 env.addActual( actual.env, openVars );
    970 
    971959                                                unsigned nextExpl = results[i].nextExpl + 1;
    972                                                 if ( nextExpl == expl.alts.size() ) {
     960                                                if ( nextExpl == expl.exprs.size() ) {
    973961                                                        nextExpl = 0;
    974962                                                }
    975963
    976964                                                results.emplace_back(
    977                                                         i, actual.expr, move(env), copy(results[i].need),
    978                                                         copy(results[i].have), move(openVars), nextArg, 0,
    979                                                         Cost::zero, nextExpl, results[i].explAlt );
     965                                                        i, expl.exprs[results[i].nextExpl].get(), copy(results[i].env),
     966                                                        copy(results[i].need), copy(results[i].have),
     967                                                        copy(results[i].openVars), nextArg, 0, Cost::zero, nextExpl,
     968                                                        results[i].explAlt );
    980969                                               
    981970                                                continue;
     
    1000989
    1001990                                                // skip empty tuple arguments by (near-)cloning parent into next gen
    1002                                                 if ( expl.alts.empty() ) {
     991                                                if ( expl.exprs.empty() ) {
    1003992                                                        results.emplace_back(
    1004993                                                                results[i], move(env), copy(results[i].need),
     
    1010999                                                // add new result
    10111000                                                results.emplace_back(
    1012                                                         i, expl.alts.front().expr, move(env), copy(results[i].need),
     1001                                                        i, expl.exprs.front().get(), move(env), copy(results[i].need),
    10131002                                                        copy(results[i].have), move(openVars), nextArg + 1, 0,
    1014                                                         expl.cost, expl.alts.size() == 1 ? 0 : 1, j );
     1003                                                        expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
    10151004                                        }
    10161005                                }
  • src/ResolvExpr/ExplodedActual.cc

    ra8b27c6 r62194cb  
    2020namespace ResolvExpr {
    2121        ExplodedActual::ExplodedActual( const Alternative& actual, const SymTab::Indexer& indexer )
    22                         : env(actual.env), cost(actual.cost), alts() {
    23                 Tuples::explode( actual, indexer, back_inserter( alts ) );
     22                        : env(actual.env), cost(actual.cost), exprs() {
     23                Tuples::explode( actual, indexer, *this );
    2424        }
    2525}
  • src/ResolvExpr/ExplodedActual.h

    ra8b27c6 r62194cb  
    1616#pragma once
    1717
     18#include <memory>
     19#include <vector>
     20
    1821#include "Alternative.h"      // for Alternative, AltList
    1922#include "Cost.h"             // for Cost
     
    2629                TypeEnvironment env;
    2730                Cost cost;
    28                 AltList alts;  // TODO flatten this down to vector<unique_ptr<Expression>>
     31                std::vector< std::unique_ptr<Expression> > exprs;
    2932
    30                 ExplodedActual() : env(), cost(Cost::zero), alts() {}
     33                ExplodedActual() : env(), cost(Cost::zero), exprs() {}
    3134
    32                 ExplodedActual( const Alternative& actual, const SymTab::Indexer& indexer );   
     35                ExplodedActual( const Alternative& actual, const SymTab::Indexer& indexer );
    3336        };
    3437}
  • src/Tuples/Explode.h

    ra8b27c6 r62194cb  
    1616#pragma once
    1717
    18 #include <iterator>                  // for back_inserter, back_insert_iterator
     18#include <iterator>                     // for back_inserter, back_insert_iterator
     19#include <utility>                      // for forward
    1920
    20 #include "ResolvExpr/Alternative.h"  // for Alternative, AltList
    21 #include "SynTree/Expression.h"      // for Expression, UniqueExpr, AddressExpr
    22 #include "SynTree/Type.h"            // for TupleType, Type
    23 #include "Tuples.h"                  // for maybeImpure
     21#include "ResolvExpr/Alternative.h"     // for Alternative, AltList
     22#include "ResolvExpr/ExplodedActual.h"  // for ExplodedActual
     23#include "SynTree/Expression.h"         // for Expression, UniqueExpr, AddressExpr
     24#include "SynTree/Type.h"               // for TupleType, Type
     25#include "Tuples.h"                     // for maybeImpure
    2426
    2527namespace SymTab {
     
    3941        }
    4042
     43        /// Append alternative to an OutputIterator of Alternatives
     44        template<typename OutputIterator>
     45        void append( OutputIterator out, Expression* expr, const ResolvExpr::TypeEnvironment& env,
     46                        const ResolvExpr::Cost& cost, const ResolvExpr::Cost& cvtCost ) {
     47                *out++ = ResolvExpr::Alternative{ expr, env, cost, cvtCost };
     48        }
     49
     50        /// Append alternative to an ExplodedActual
     51        static inline void append( ResolvExpr::ExplodedActual& ea, Expression* expr,
     52                        const ResolvExpr::TypeEnvironment&, const ResolvExpr::Cost&, const ResolvExpr::Cost& ) {
     53                ea.exprs.emplace_back( expr );
     54                /// xxx -- merge environment, cost?
     55        }
     56
    4157        /// helper function used by explode
    42         template< typename OutputIterator >
    43         void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign ) {
     58        template< typename Output >
     59        void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt,
     60                        const SymTab::Indexer & indexer, Output&& out, bool isTupleAssign ) {
    4461                if ( isTupleAssign ) {
    4562                        // tuple assignment needs CastExprs to be recursively exploded to easily get at all of the components
    4663                        if ( CastExpr * castExpr = isReferenceCast( expr ) ) {
    4764                                ResolvExpr::AltList alts;
    48                                 explodeUnique( castExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign );
     65                                explodeUnique(
     66                                        castExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign );
    4967                                for ( ResolvExpr::Alternative & alt : alts ) {
    5068                                        // distribute reference cast over all components
    51                                         alt.expr = distributeReference( alt.expr );
    52                                         *out++ = alt;
     69                                        append( std::forward<Output>(out), distributeReference( alt.release_expr() ),
     70                                                alt.env, alt.cost, alt.cvtCost );
    5371                                }
    5472                                // in tuple assignment, still need to handle the other cases, but only if not already handled here (don't want to output too many alternatives)
     
    6179                                // can open tuple expr and dump its exploded components
    6280                                for ( Expression * expr : tupleExpr->get_exprs() ) {
    63                                         explodeUnique( expr, alt, indexer, out, isTupleAssign );
     81                                        explodeUnique( expr, alt, indexer, std::forward<Output>(out), isTupleAssign );
    6482                                }
    6583                        } else {
     
    7795                                for ( unsigned int i = 0; i < tupleType->size(); i++ ) {
    7896                                        TupleIndexExpr * idx = new TupleIndexExpr( arg->clone(), i );
    79                                         explodeUnique( idx, alt, indexer, out, isTupleAssign );
     97                                        explodeUnique( idx, alt, indexer, std::forward<Output>(out), isTupleAssign );
    8098                                        delete idx;
    8199                                }
     
    84102                } else {
    85103                        // atomic (non-tuple) type - output a clone of the expression in a new alternative
    86                         *out++ = ResolvExpr::Alternative( expr->clone(), alt.env, alt.cost, alt.cvtCost );
     104                        append( std::forward<Output>(out), expr->clone(), alt.env, alt.cost, alt.cvtCost );
    87105                }
    88106        }
    89107
    90108        /// expands a tuple-valued alternative into multiple alternatives, each with a non-tuple-type
    91         template< typename OutputIterator >
    92         void explode( const ResolvExpr::Alternative &alt, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign = false ) {
    93                 explodeUnique( alt.expr, alt, indexer, out, isTupleAssign );
     109        template< typename Output >
     110        void explode( const ResolvExpr::Alternative &alt, const SymTab::Indexer & indexer,
     111                        Output&& out, bool isTupleAssign = false ) {
     112                explodeUnique( alt.expr, alt, indexer, std::forward<Output>(out), isTupleAssign );
    94113        }
    95114
    96115        // explode list of alternatives
    97         template< typename AltIterator, typename OutputIterator >
    98         void explode( AltIterator altBegin, AltIterator altEnd, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign = false ) {
     116        template< typename AltIterator, typename Output >
     117        void explode( AltIterator altBegin, AltIterator altEnd, const SymTab::Indexer & indexer,
     118                        Output&& out, bool isTupleAssign = false ) {
    99119                for ( ; altBegin != altEnd; ++altBegin ) {
    100                         explode( *altBegin, indexer, out, isTupleAssign );
     120                        explode( *altBegin, indexer, std::forward<Output>(out), isTupleAssign );
    101121                }
    102122        }
    103123
    104         template< typename OutputIterator >
    105         void explode( const ResolvExpr::AltList & alts, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign = false ) {
    106                 explode( alts.begin(), alts.end(), indexer, out, isTupleAssign );
     124        template< typename Output >
     125        void explode( const ResolvExpr::AltList & alts, const SymTab::Indexer & indexer, Output&& out,
     126                        bool isTupleAssign = false ) {
     127                explode( alts.begin(), alts.end(), indexer, std::forward<Output>(out), isTupleAssign );
    107128        }
    108129} // namespace Tuples
Note: See TracChangeset for help on using the changeset viewer.