Changes in src/Tuples/Explode.h [7870799:490ff5c3]

File:

• src/Tuples/Explode.h (modified) (6 diffs)

src/Tuples/Explode.h

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Wed Nov 9 13:12:24 2016
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Jun 17 14:36:00 2019
-// Update Count     : 4
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Jul 22 09:55:16 2017
+// Update Count     : 3
 //
 
@@ -19 +19 @@
 #include <utility>                      // for forward
 
-#include "AST/Expr.hpp"
 #include "ResolvExpr/Alternative.h"     // for Alternative, AltList
-#include "ResolvExpr/Candidate.hpp"     // for Candidate, CandidateList
 #include "ResolvExpr/ExplodedActual.h"  // for ExplodedActual
-#include "ResolvExpr/ExplodedArg.hpp"   // for ExplodedArg
 #include "SynTree/Expression.h"         // for Expression, UniqueExpr, AddressExpr
 #include "SynTree/Type.h"               // for TupleType, Type
 #include "Tuples.h"                     // for maybeImpure
-
-namespace ast {
-        class SymbolTable;
-}
 
 namespace SymTab {
@@ -51 +44 @@
         template<typename OutputIterator>
         void append( OutputIterator out, Expression* expr, const ResolvExpr::TypeEnvironment& env,
-                        const ResolvExpr::OpenVarSet& openVars, const ResolvExpr::AssertionList& need,
                         const ResolvExpr::Cost& cost, const ResolvExpr::Cost& cvtCost ) {
-                *out++ = ResolvExpr::Alternative{ expr, env, openVars, need, cost, cvtCost };
+                *out++ = ResolvExpr::Alternative{ expr, env, cost, cvtCost };
         }
 
         /// Append alternative to an ExplodedActual
         static inline void append( ResolvExpr::ExplodedActual& ea, Expression* expr,
-                        const ResolvExpr::TypeEnvironment&, const ResolvExpr::OpenVarSet&,
-                        const ResolvExpr::AssertionList&, const ResolvExpr::Cost&, const ResolvExpr::Cost& ) {
+                        const ResolvExpr::TypeEnvironment&, const ResolvExpr::Cost&, const ResolvExpr::Cost& ) {
                 ea.exprs.emplace_back( expr );
-                /// xxx -- merge environment, openVars, need, cost?
+                /// xxx -- merge environment, cost?
         }
 
@@ -77 +68 @@
                                         // distribute reference cast over all components
                                         append( std::forward<Output>(out), distributeReference( alt.release_expr() ),
-                                                alt.env, alt.openVars, alt.need, alt.cost, alt.cvtCost );
+                                                alt.env, alt.cost, alt.cvtCost );
                                 }
                                 // 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)
@@ -111 +102 @@
                 } else {
                         // atomic (non-tuple) type - output a clone of the expression in a new alternative
-                        append( std::forward<Output>(out), expr->clone(), alt.env, alt.openVars, alt.need,
-                                alt.cost, alt.cvtCost );
+                        append( std::forward<Output>(out), expr->clone(), alt.env, alt.cost, alt.cvtCost );
                 }
         }
@@ -137 +127 @@
                 explode( alts.begin(), alts.end(), indexer, std::forward<Output>(out), isTupleAssign );
         }
-
-const ast::Expr * distributeReference( const ast::Expr * );
-
-/// Append candidate to an OutputIterator of Candidates.
-template<typename OutputIterator>
-void append( OutputIterator out, const ast::Expr * expr, const ast::TypeEnvironment & env,
-                const ast::OpenVarSet & open, const ast::AssertionList & need,
-                const ResolvExpr::Cost & cost, const ResolvExpr::Cost & cvtCost ) {
-        ast::TypeEnvironment copyEnv = env;
-        ast::OpenVarSet copyOpen = open;
-        ast::AssertionSet set;
-        mergeAssertionSet( set, need );
-        *out++ = std::make_shared<ResolvExpr::Candidate>( expr, std::move( copyEnv ),
-                std::move( copyOpen ), std::move( set ), cost, cvtCost );
-}
-
-/// Append candidate to an ExplodedArg.
-static inline void append( ResolvExpr::ExplodedArg& ea, const ast::Expr * expr,
-                const ast::TypeEnvironment&, const ast::OpenVarSet&,
-                const ast::AssertionList&, const ResolvExpr::Cost&, const ResolvExpr::Cost& ) {
-        // I'm not sure why most of the arguments are unused. But they were in the old version.
-        ea.exprs.emplace_back( expr );
-}
-
-/// Check if the expression is a cast to a reference type, return it if it is.
-static inline const ast::CastExpr * isReferenceCast( const ast::Expr * expr ) {
-        if ( const ast::CastExpr * cast = dynamic_cast< const ast::CastExpr * >( expr ) ) {
-                if ( dynamic_cast< const ast::ReferenceType * >( cast->result.get() ) ) {
-                        return cast;
-                }
-        }
-        return nullptr;
-}
-
-/// helper function (indirectely) used by explode
-template< typename Output >
-void explodeRecursive(
-        const ast::CastExpr *, const ResolvExpr::Candidate &,
-        const ast::SymbolTable &, Output &&
-) {
-}
-
-/// helper function used by explode
-template< typename Output >
-void explodeUnique(
-        const ast::ptr< ast::Expr > & expr, const ResolvExpr::Candidate & arg,
-        const ast::SymbolTable & symtab, Output && out, bool isTupleAssign
-) {
-        // Tuple assignment can use a faster method if it is cast. Uses recursive exploding.
-        if ( isTupleAssign ) if ( const ast::CastExpr * castExpr = isReferenceCast( expr ) ) {
-                ResolvExpr::CandidateList candidates;
-                explodeUnique( castExpr->arg, arg, symtab, back_inserter( candidates ), true );
-                for ( ResolvExpr::CandidateRef & cand : candidates ) {
-                        // Distribute the reference cast over all components of the candidate.
-                        append( std::forward<Output>(out), distributeReference( cand->expr ), cand->env,
-                                cand->open, cand->need, cand->cost, cand->cvtCost );
-                }
-                return;
-        }
-        const ast::Type * res = expr->result->stripReferences();
-        if ( const ast::TupleType * tupleType = dynamic_cast< const ast::TupleType * >( res ) ) {
-                if ( const ast::ptr< ast::TupleExpr > & tupleExpr = expr.as< ast::TupleExpr >() ) {
-                        // Open the tuple expr and continue on its components.
-                        for ( const ast::Expr * expr : tupleExpr->exprs ) {
-                                explodeUnique( expr, arg, symtab, std::forward<Output>(out), isTupleAssign );
-                        }
-                } else {
-                        ast::ptr< ast::Expr > local = expr;
-                        // Expressions which may have side effects require a single unique instance.
-                        if ( Tuples::maybeImpureIgnoreUnique( local ) ) {
-                                local = new ast::UniqueExpr( local->location, local );
-                        }
-                        // Cast a reference away to a value-type to allow further explosion.
-                        if ( dynamic_cast< const ast::ReferenceType *>( local->result.get() ) ) {
-                                local = new ast::CastExpr{ local, tupleType };
-                        }
-                        // Now we have to go across the tuple via indexing.
-                        for ( unsigned int i = 0 ; i < tupleType->size() ; ++i ) {
-                                ast::TupleIndexExpr * idx = new ast::TupleIndexExpr( local->location, local, i );
-                                explodeUnique( idx, arg, symtab, std::forward<Output>(out), isTupleAssign );
-                                // TODO: We need more input to figure out the exact lifetimes of these types.
-                                // delete idx;
-                        }
-                        // delete local;
-                }
-        } else {
-                // For atomic/non-tuple types, no explosion is used.
-                append( std::forward<Output>(out), expr, arg.env, arg.open, arg.need, arg.cost,
-                        arg.cvtCost );
-        }
-}
-
-/// expands a tuple-valued candidate into multiple candidates, each with a non-tuple type
-template< typename Output >
-void explode(
-        const ResolvExpr::Candidate & arg, const ast::SymbolTable & symtab, Output && out,
-        bool isTupleAssign = false
-) {
-        explodeUnique( arg.expr, arg, symtab, std::forward< Output >( out ), isTupleAssign );
-}
-
-/// explode list of candidates into flattened list of candidates
-template< typename Output >
-void explode(
-        const ResolvExpr::CandidateList & cands, const ast::SymbolTable & symtab, Output && out,
-        bool isTupleAssign = false
-) {
-        for ( const ResolvExpr::CandidateRef & cand : cands ) {
-                explode( *cand, symtab, std::forward< Output >( out ), isTupleAssign );
-        }
-}
-
 } // namespace Tuples