Changes in / [98a8290:4ae2364]

Location:

src

Files:

• InitTweak/FixInit.cc (modified) (8 diffs)
• SynTree/Expression.cc (modified) (1 diff)
• SynTree/Expression.h (modified) (2 diffs)

src/InitTweak/FixInit.cc

@@ -72 +72 @@
                 };
 
-                struct StmtExprResult {
-                        static void link( std::list< Declaration * > & translationUnit );
-
-                        void previsit( StmtExpr * stmtExpr );
-                };
-
                 struct InsertImplicitCalls : public WithConstTypeSubstitution {
                         /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which
@@ -232 +226 @@
                 acceptAll( translationUnit, checker );
 
-                // fixes StmtExpr to properly link to their resulting expression
-                StmtExprResult::link( translationUnit );
-
                 // fixes ConstructorInit for global variables. should happen before fixInitializers.
                 InitTweak::fixGlobalInit( translationUnit, inLibrary );
@@ -308 +299 @@
 
                         return dtorFunc;
-                }
-
-                void StmtExprResult::link( std::list< Declaration * > & translationUnit ) {
-                        PassVisitor<StmtExprResult> linker;
-                        acceptAll( translationUnit, linker );
                 }
 
@@ -363 +349 @@
                         PassVisitor<FixCtorExprs> fixer;
                         mutateAll( translationUnit, fixer );
-                }
-
-                void StmtExprResult::previsit( StmtExpr * stmtExpr ) {
-                        // we might loose the result expression here so add a pointer to trace back
-                        assert( stmtExpr->result );
-                        Type * result = stmtExpr->result;
-                        if ( ! result->isVoid() ) {
-                                CompoundStmt * body = stmtExpr->statements;
-                                assert( ! body->kids.empty() );
-                                stmtExpr->resultExpr = strict_dynamic_cast< ExprStmt * >( body->kids.back() );
-                        }
                 }
 
@@ -680 +655 @@
                         // function call temporaries should be placed at statement-level, rather than nested inside of a new statement expression,
                         // since temporaries can be shared across sub-expressions, e.g.
-                        //   [A, A] f();       // decl
-                        //   g([A] x, [A] y);  // decl
-                        //   g(f());           // call
+                        //   [A, A] f();
+                        //   g([A] x, [A] y);
+                        //   g(f());
                         // f is executed once, so the return temporary is shared across the tuple constructors for x and y.
                         // Explicitly mutating children instead of mutating the inner compound statement forces the temporaries to be added
@@ -690 +665 @@
                         assert( env );
 
-                        indexer.enterScope();
                         // visit all statements
                         std::list< Statement * > & stmts = stmtExpr->statements->get_kids();
@@ -696 +670 @@
                                 stmt = stmt->acceptMutator( *visitor );
                         } // for
-                        indexer.leaveScope();
 
                         assert( stmtExpr->result );
@@ -715 +688 @@
                                 stmtsToAddBefore.push_back( new DeclStmt( ret ) );
 
-                                if(!stmtExpr->resultExpr) {
-                                        SemanticError(stmtExpr, "Statment-Expression should have a resulting expression");
-                                }
-                                ExprStmt * last = stmtExpr->resultExpr;
-                                try {
-                                        last->expr = makeCtorDtor( "?{}", ret, last->expr );
-                                } catch(...) {
-                                        std::cerr << "=======================" << std::endl;
-                                        std::cerr << "ERROR, can't resolve" << std::endl;
-                                        ret->print(std::cerr);
-                                        std::cerr << std::endl << "---" << std::endl;
-                                        last->expr->print(std::cerr);
-
-                                        abort();
-                                }
+                                // must have a non-empty body, otherwise it wouldn't have a result
+                                CompoundStmt * body = stmtExpr->statements;
+                                assert( ! body->kids.empty() );
+                                // must be an ExprStmt, otherwise it wouldn't have a result
+                                ExprStmt * last = strict_dynamic_cast< ExprStmt * >( body->kids.back() );
+                                last->expr = makeCtorDtor( "?{}", ret, last->expr );
 
                                 // add destructors after current statement

src/SynTree/Expression.cc

@@ -610 +610 @@
         computeResult();
 }
-StmtExpr::StmtExpr( const StmtExpr & other ) : Expression( other ), statements( other.statements->clone() ), resultExpr( other.resultExpr ) {
+StmtExpr::StmtExpr( const StmtExpr & other ) : Expression( other ), statements( other.statements->clone() ) {
         cloneAll( other.returnDecls, returnDecls );
         cloneAll( other.dtors, dtors );

src/SynTree/Expression.h

@@ -62 +62 @@
         InferredParams inferParams;       ///< Post-resolution inferred parameter slots
         std::vector<UniqueId> resnSlots;  ///< Pre-resolution inferred parameter slots
-
+        
         // xxx - should turn inferParams+resnSlots into a union to save some memory
 
@@ -744 +744 @@
         std::list< Expression * > dtors; // destructor(s) for return variable(s)
 
-        // readonly
-        ExprStmt * resultExpr = nullptr;
-
         StmtExpr( CompoundStmt * statements );
         StmtExpr( const StmtExpr & other );