Changeset 1d2b64f for src/Tuples

Timestamp:

Dec 13, 2016, 5:20:54 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

d5556a3

Parents:

722617d

git-author:

Rob Schluntz <rschlunt@…> (12/13/16 17:16:27)

git-committer:

Rob Schluntz <rschlunt@…> (12/13/16 17:20:54)

Message:

combine environments and costs in tuple assignment, resolve ctor/dtors for tuple assignment temporaries

File:

• src/Tuples/TupleAssignment.cc (modified) (6 diffs)

src/Tuples/TupleAssignment.cc ¶

@@ -23 +23 @@
 #include "Common/SemanticError.h"
 #include "InitTweak/InitTweak.h"
+#include "InitTweak/GenInit.h"
 
 #include <functional>
@@ -47 +48 @@
                         virtual ~Matcher() {}
                         virtual void match( std::list< Expression * > &out ) = 0;
+                        ObjectDecl * newObject( UniqueName & namer, Expression * expr );
                         ResolvExpr::AltList lhs, rhs;
                         TupleAssignSpotter &spotter;
+                        ResolvExpr::Cost baseCost;
                         std::list< ObjectDecl * > tmpDecls;
+                        ResolvExpr::TypeEnvironment compositeEnv;
                 };
 
@@ -146 +150 @@
                                 finder.findWithAdjustment(*i);
                         } catch (...) {
-                                return; // xxx - no match should not mean failure, it just means this particular tuple assignment isn't valid
+                                return; // no match should not mean failure, it just means this particular tuple assignment isn't valid
                         }
                         // prune expressions that don't coincide with
@@ -161 +165 @@
                         solved_assigns.push_back( alt.expr->clone() );
                 }
-                // xxx - need to do this??
-                ResolvExpr::TypeEnvironment compositeEnv;
-                simpleCombineEnvironments( current.begin(), current.end(), compositeEnv );
-                currentFinder.get_alternatives().push_front( ResolvExpr::Alternative(new TupleAssignExpr(solved_assigns, matcher->tmpDecls), compositeEnv, ResolvExpr::sumCost( current ) ) );
-        }
-
-        TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList &alts ) : spotter(spotter) {
+                // combine assignment environments into combined expression environment
+                simpleCombineEnvironments( current.begin(), current.end(), matcher->compositeEnv );
+                currentFinder.get_alternatives().push_front( ResolvExpr::Alternative(new TupleAssignExpr(solved_assigns, matcher->tmpDecls), matcher->compositeEnv, ResolvExpr::sumCost( current  ) + matcher->baseCost ) );
+        }
+
+        TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList &alts ) : spotter(spotter), baseCost( ResolvExpr::sumCost( alts ) ) {
                 assert( ! alts.empty() );
+                // combine argument environments into combined expression environment
+                simpleCombineEnvironments( alts.begin(), alts.end(), compositeEnv );
+
                 ResolvExpr::Alternative lhsAlt = alts.front();
                 // peel off the cast that exists on ctor/dtor expressions
@@ -217 +223 @@
         }
 
-        ObjectDecl * newObject( UniqueName & namer, Expression * expr ) {
+        // removes environments from subexpressions within statement exprs, which could throw off later passes like those in Box which rely on PolyMutator.
+        // xxx - maybe this should happen in alternative finder for every StmtExpr?
+        // xxx - it's possible that these environments could contain some useful information. Maybe the right thing to do is aggregate the environments and pass the aggregate back to be added into the compositeEnv
+        struct EnvRemover : public Visitor {
+                virtual void visit( ExprStmt * stmt ) {
+                        delete stmt->get_expr()->get_env();
+                        stmt->get_expr()->set_env( nullptr );
+                        Visitor::visit( stmt );
+                }
+        };
+
+        ObjectDecl * TupleAssignSpotter::Matcher::newObject( UniqueName & namer, Expression * expr ) {
                 assert( expr->has_result() && ! expr->get_result()->isVoid() );
-                return new ObjectDecl( namer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
+                ObjectDecl * ret = new ObjectDecl( namer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
+                ConstructorInit * ctorInit = InitTweak::genCtorInit( ret );
+                ret->set_init( ctorInit );
+                ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object
+                EnvRemover rm; // remove environments from subexpressions of StmtExprs
+                ctorInit->accept( rm );
+                return ret;
         }
 
@@ -244 +267 @@
                         std::list< ObjectDecl * > ltmp;
                         std::list< ObjectDecl * > rtmp;
-                        std::transform( lhs.begin(), lhs.end(), back_inserter( ltmp ), []( ResolvExpr::Alternative & alt ){
+                        std::transform( lhs.begin(), lhs.end(), back_inserter( ltmp ), [&]( ResolvExpr::Alternative & alt ){
                                 return newObject( lhsNamer, alt.expr );
                         });
-                        std::transform( rhs.begin(), rhs.end(), back_inserter( rtmp ), []( ResolvExpr::Alternative & alt ){
+                        std::transform( rhs.begin(), rhs.end(), back_inserter( rtmp ), [&]( ResolvExpr::Alternative & alt ){
                                 return newObject( rhsNamer, alt.expr );
                         });