Changeset 1d2b64f

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

Location:

src

Files:

• ResolvExpr/Resolver.cc (modified) (10 diffs)
• ResolvExpr/Resolver.h (modified) (1 diff)
• Tuples/TupleAssignment.cc (modified) (6 diffs)

src/ResolvExpr/Resolver.cc

@@ -36 +36 @@
           public:
                 Resolver() : SymTab::Indexer( false ) {}
-
-                using SymTab::Indexer::visit;
+                Resolver( const SymTab:: Indexer & other ) : SymTab::Indexer( other ) {
+                        if ( const Resolver * res = dynamic_cast< const Resolver * >( &other ) ) {
+                                functionReturn = res->functionReturn;
+                                initContext = res->initContext;
+                                inEnumDecl = res->inEnumDecl;
+                        }
+                }
+
+                typedef SymTab::Indexer Parent;
+                using Parent::visit;
                 virtual void visit( FunctionDecl *functionDecl ) override;
                 virtual void visit( ObjectDecl *functionDecl ) override;
@@ -192 +200 @@
                         initContext = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
                 }
-                SymTab::Indexer::visit( objectDecl );
+                Parent::visit( objectDecl );
                 if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
                         // delete newly created signed int type
@@ -212 +220 @@
         void Resolver::visit( ArrayType * at ) {
                 handlePtrType( at );
-                Visitor::visit( at );
+                Parent::visit( at );
         }
 
         void Resolver::visit( PointerType * pt ) {
                 handlePtrType( pt );
-                Visitor::visit( pt );
+                Parent::visit( pt );
         }
 
@@ -225 +233 @@
                         typeDecl->set_base( new_type );
                 } // if
-                SymTab::Indexer::visit( typeDecl );
+                Parent::visit( typeDecl );
         }
 
@@ -238 +246 @@
                 ValueGuard< Type * > oldFunctionReturn( functionReturn );
                 functionReturn = ResolvExpr::extractResultType( functionDecl->get_functionType() );
-                SymTab::Indexer::visit( functionDecl );
+                Parent::visit( functionDecl );
         }
 
         void Resolver::visit( EnumDecl * enumDecl ) {
                 // in case we decide to allow nested enums
-                bool oldInEnumDecl = inEnumDecl;
+                ValueGuard< bool > oldInEnumDecl( inEnumDecl );
                 inEnumDecl = true;
-                SymTab::Indexer::visit( enumDecl );
-                inEnumDecl = oldInEnumDecl;
+                Parent::visit( enumDecl );
         }
 
         void Resolver::visit( ExprStmt *exprStmt ) {
-                if ( exprStmt->get_expr() ) {
-                        Expression *newExpr = findVoidExpression( exprStmt->get_expr(), *this );
-                        delete exprStmt->get_expr();
-                        exprStmt->set_expr( newExpr );
-                } // if
+                assertf( exprStmt->get_expr(), "ExprStmt has null Expression in resolver" );
+                Expression *newExpr = findVoidExpression( exprStmt->get_expr(), *this );
+                delete exprStmt->get_expr();
+                exprStmt->set_expr( newExpr );
         }
 
@@ -277 +283 @@
                 delete ifStmt->get_condition();
                 ifStmt->set_condition( newExpr );
-                Visitor::visit( ifStmt );
+                Parent::visit( ifStmt );
         }
 
@@ -284 +290 @@
                 delete whileStmt->get_condition();
                 whileStmt->set_condition( newExpr );
-                Visitor::visit( whileStmt );
+                Parent::visit( whileStmt );
         }
 
         void Resolver::visit( ForStmt *forStmt ) {
-                SymTab::Indexer::visit( forStmt );
+                Parent::visit( forStmt );
 
                 if ( forStmt->get_condition() ) {
@@ -318 +324 @@
 
         void Resolver::visit( CaseStmt *caseStmt ) {
-                Visitor::visit( caseStmt );
+                Parent::visit( caseStmt );
         }
 
@@ -482 +488 @@
                         } else {
                                 // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
-                                Visitor::visit( listInit );
+                                Parent::visit( listInit );
                         }
                 } else {
                         assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext )
-                                || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) );
+                                || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) || dynamic_cast < EnumInstType * > ( initContext ) );
                         // basic types are handled here
-                        Visitor::visit( listInit );
+                        Parent::visit( listInit );
                 }
 
@@ -554 +560 @@
         }
 
+        // needs to be callable from outside the resolver, so this is a standalone function
+        void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer ) {
+                assert( ctorInit );
+                Resolver resolver( indexer );
+                ctorInit->accept( resolver );
+        }
+
+        void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer ) {
+                assert( stmtExpr );
+                Resolver resolver( indexer );
+                stmtExpr->accept( resolver );
+        }
+
         void Resolver::visit( ConstructorInit *ctorInit ) {
                 // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit

src/ResolvExpr/Resolver.h

@@ -25 +25 @@
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer );
         Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer );
+        void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );
+        void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer );
 } // namespace ResolvExpr
 

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 );
                         });