Changeset b910d15 for src/Tuples/Explode.h

Timestamp:

Jun 17, 2019, 3:55:21 PM (5 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

e6faef4

Parents:

6e55240

Message:

Implemented new versions of Tuples/Explode?.

File:

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

src/Tuples/Explode.h

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Wed Nov 9 13:12:24 2016
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:55:16 2017
-// Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Jun 17 14:36:00 2019
+// Update Count     : 4
 //
 
@@ -138 +138 @@
         }
 
+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 * expr, const ResolvExpr::Candidate & arg,
+        const ast::SymbolTable & symtab, Output && out
+) {
+}
+
 /// helper function used by explode
 template< typename Output >
-void explodeUnique( 
-        const ast::Expr * expr, const ResolvExpr::Candidate & arg, const ast::SymbolTable & symtab, 
-        Output && out, bool isTupleAssign
+void explodeUnique(
+        const ast::ptr< ast::Expr > & expr, const ResolvExpr::Candidate & arg,
+        const ast::SymbolTable & symtab, Output && out, bool isTupleAssign
 ) {
-        #warning unimplemented
-        (void)expr; (void)arg; (void)symtab; (void)out; (void)isTupleAssign;
-        assert(false);
+        // 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->location, 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, 
+void explode(
+        const ResolvExpr::Candidate & arg, const ast::SymbolTable & symtab, Output && out,
         bool isTupleAssign = false
 ) {