Changes in / [379b6ea:8ef0bf7]

Location:

src

Files:

• AST/Expr.cpp (modified) (1 diff)
• AST/Expr.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (1 diff)
• AST/Print.cpp (modified) (1 diff)
• InitTweak/FixInit.cpp (modified) (2 diffs)

src/AST/Expr.cpp

@@ -393 +393 @@
 
 StmtExpr::StmtExpr( const CodeLocation & loc, const CompoundStmt * ss )
-: Expr( loc ), stmts( ss ) { computeResult(); }
+: Expr( loc ), stmts( ss ), returnDecls(), dtors() { computeResult(); }
 
 void StmtExpr::computeResult() {
         assert( stmts );
         const std::list<ptr<Stmt>> & body = stmts->kids;
-        // If there is a tail expression, its result is entire result.
-        if ( !body.empty() && ( resultExpr = body.back().as<ExprStmt>() ) ) {
-                result = resultExpr->expr->result;
-        // Otherwise, fill in the result with void so there is a result type.
-        } else {
-                result = new VoidType();
-        }
+        if ( ! returnDecls.empty() ) {
+                // prioritize return decl for result type, since if a return decl exists, then the StmtExpr
+                // is currently in an intermediate state where the body will always give a void result type
+                result = returnDecls.front()->get_type();
+        } else if ( ! body.empty() ) {
+                if ( const ExprStmt * exprStmt = body.back().as< ExprStmt >() ) {
+                        result = exprStmt->expr->result;
+                }
+        }
+        // ensure a result type exists
+        if ( ! result ) { result = new VoidType{}; }
 }
 

src/AST/Expr.hpp

@@ -782 +782 @@
 public:
         ptr<CompoundStmt> stmts;
+        std::vector<ptr<ObjectDecl>> returnDecls;  ///< return variable(s) for statement expression
+        std::vector<ptr<Expr>> dtors;              ///< destructor(s) for return variable(s)
 
         readonly<ExprStmt> resultExpr;

src/AST/Pass.impl.hpp

@@ -1697 +1697 @@
                 }
                 maybe_accept( node, &StmtExpr::stmts       );
+                maybe_accept( node, &StmtExpr::returnDecls );
+                maybe_accept( node, &StmtExpr::dtors       );
         }
 

src/AST/Print.cpp

@@ -1406 +1406 @@
                 os << "Statement Expression:" << endl << indent;
                 safe_print( node->stmts );
+                if ( ! node->returnDecls.empty() ) {
+                        os << indent << "... with returnDecls: ";
+                        printAll( node->returnDecls );
+                }
+                if ( ! node->dtors.empty() ) {
+                        os << indent << "... with dtors: ";
+                        printAll( node->dtors );
+                }
                 --indent;
                 postprint( node );

src/InitTweak/FixInit.cpp

@@ -697 +697 @@
         assert( stmtExpr->result );
         if ( stmtExpr->result->isVoid() ) {
+                assert( stmtExpr->returnDecls.empty() );
+                assert( stmtExpr->dtors.empty() );
+
                 return stmtExpr;
         }
@@ -744 +747 @@
         // if there is a return decl, add a use as the last statement; will not have return decl on non-constructable returns
         stmts.push_back( new ast::ExprStmt(loc, new ast::VariableExpr(loc, ret ) ) );
+
+        assert( stmtExpr->returnDecls.empty() );
+        assert( stmtExpr->dtors.empty() );
 
         return stmtExpr;