Changes in src/Tuples/TupleExpansion.cc [be9288a:9f10c4b8]

File:

• src/Tuples/TupleExpansion.cc (modified) (15 diffs)

src/Tuples/TupleExpansion.cc

@@ -14 +14 @@
 //
 
-#include <stddef.h>               // for size_t
-#include <cassert>                // for assert
-#include <list>                   // for list
-
-#include "Common/PassVisitor.h"   // for PassVisitor, WithDeclsToAdd, WithGu...
-#include "Common/ScopedMap.h"     // for ScopedMap
-#include "Common/utility.h"       // for CodeLocation
-#include "GenPoly/DeclMutator.h"  // for DeclMutator
-#include "InitTweak/InitTweak.h"  // for getFunction
-#include "Parser/LinkageSpec.h"   // for Spec, C, Intrinsic
-#include "SynTree/Constant.h"     // for Constant
-#include "SynTree/Declaration.h"  // for StructDecl, DeclarationWithType
-#include "SynTree/Expression.h"   // for UntypedMemberExpr, Expression, Uniq...
-#include "SynTree/Label.h"        // for operator==, Label
-#include "SynTree/Mutator.h"      // for Mutator
-#include "SynTree/Type.h"         // for Type, Type::Qualifiers, TupleType
-#include "SynTree/Visitor.h"      // for Visitor
-
-class CompoundStmt;
-class TypeSubstitution;
+#include <iterator>
+#include <iostream>
+#include <cassert>
+#include "Tuples.h"
+#include "Common/PassVisitor.h"
+#include "Common/ScopedMap.h"
+#include "GenPoly/DeclMutator.h"
+#include "InitTweak/GenInit.h"
+#include "InitTweak/InitTweak.h"
+#include "ResolvExpr/typeops.h"
+#include "SymTab/Mangler.h"
+#include "SynTree/Declaration.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Initializer.h"
+#include "SynTree/Mutator.h"
+#include "SynTree/Statement.h"
+#include "SynTree/Type.h"
 
 namespace Tuples {
         namespace {
-                class MemberTupleExpander final : public Mutator {
-                public:
+                struct MemberTupleExpander final : public Mutator {
                         typedef Mutator Parent;
                         using Parent::mutate;
@@ -45 +41 @@
                 };
 
-                class UniqueExprExpander final : public GenPoly::DeclMutator {
-                public:
-                        typedef GenPoly::DeclMutator Parent;
-                        using Parent::mutate;
-
-                        virtual Expression * mutate( UniqueExpr * unqExpr ) override;
+                struct UniqueExprExpander final : public WithDeclsToAdd {
+                        Expression * postmutate( UniqueExpr * unqExpr );
 
                         std::map< int, Expression * > decls; // not vector, because order added may not be increasing order
@@ -61 +53 @@
                 };
 
-                class TupleAssignExpander : public Mutator {
-                public:
-                        typedef Mutator Parent;
-                        using Parent::mutate;
-
-                        virtual Expression * mutate( TupleAssignExpr * tupleExpr );
+                struct TupleAssignExpander {
+                        Expression * postmutate( TupleAssignExpr * tupleExpr );
                 };
 
@@ -79 +67 @@
                 };
 
-                class TupleIndexExpander {
-                public:
+                struct TupleIndexExpander {
                         Expression * postmutate( TupleIndexExpr * tupleExpr );
                 };
 
-                class TupleExprExpander final : public Mutator {
-                public:
-                        typedef Mutator Parent;
-                        using Parent::mutate;
-
-                        virtual Expression * mutate( TupleExpr * tupleExpr ) override;
+                struct TupleExprExpander final {
+                        Expression * postmutate( TupleExpr * tupleExpr );
                 };
         }
@@ -99 +82 @@
 
         void expandUniqueExpr( std::list< Declaration * > & translationUnit ) {
-                UniqueExprExpander unqExpander;
-                unqExpander.mutateDeclarationList( translationUnit );
+                PassVisitor<UniqueExprExpander> unqExpander;
+                mutateAll( translationUnit, unqExpander );
         }
 
         void expandTuples( std::list< Declaration * > & translationUnit ) {
-                TupleAssignExpander assnExpander;
+                PassVisitor<TupleAssignExpander> assnExpander;
                 mutateAll( translationUnit, assnExpander );
 
@@ -113 +96 @@
                 mutateAll( translationUnit, idxExpander );
 
-                TupleExprExpander exprExpander;
+                PassVisitor<TupleExprExpander> exprExpander;
                 mutateAll( translationUnit, exprExpander );
         }
@@ -146 +129 @@
                         // aggregate expressions which might be impure must be wrapped in unique expressions
                         // xxx - if there's a member-tuple expression nested in the aggregate, this currently generates the wrong code if a UniqueExpr is not used, and it's purely an optimization to remove the UniqueExpr
-                        // if ( Tuples::maybeImpure( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr );
+                        // if ( Tuples::maybeImpureIgnoreUnique( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr );
                         aggr = new UniqueExpr( aggr );
                         for ( Expression *& expr : tupleExpr->get_exprs() ) {
@@ -164 +147 @@
         }
 
-        Expression * UniqueExprExpander::mutate( UniqueExpr * unqExpr ) {
-                unqExpr = safe_dynamic_cast< UniqueExpr * > ( Parent::mutate( unqExpr ) );
+        Expression * UniqueExprExpander::postmutate( UniqueExpr * unqExpr ) {
                 const int id = unqExpr->get_id();
 
@@ -175 +157 @@
                         if ( unqExpr->get_object() ) {
                                 // an object was generated to represent this unique expression -- it should be added to the list of declarations now
-                                addDeclaration( unqExpr->get_object() );
+                                declsToAddBefore.push_back( unqExpr->get_object() );
                                 unqExpr->set_object( nullptr );
                                 // steal the expr from the unqExpr
@@ -189 +171 @@
                         ObjectDecl * finished = new ObjectDecl( toString( "_unq", id, "_finished_" ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ),
                                                                                                         new SingleInit( new ConstantExpr( Constant::from_int( 0 ) ) ) );
-                        addDeclaration( finished );
+                        declsToAddBefore.push_back( finished );
                         // (finished ? _unq_expr_N : (_unq_expr_N = <unqExpr->get_expr()>, finished = 1, _unq_expr_N))
                         // This pattern ensures that each unique expression is evaluated once, regardless of evaluation order of the generated C code.
@@ -203 +185 @@
         }
 
-        Expression * TupleAssignExpander::mutate( TupleAssignExpr * assnExpr ) {
-                assnExpr = safe_dynamic_cast< TupleAssignExpr * >( Parent::mutate( assnExpr ) );
+        Expression * TupleAssignExpander::postmutate( TupleAssignExpr * assnExpr ) {
                 StmtExpr * ret = assnExpr->get_stmtExpr();
                 assnExpr->set_stmtExpr( nullptr );
@@ -238 +219 @@
                 for ( auto p : group_iterate( tupleType->get_types(), decl->get_parameters() ) ) {
                         Type * t = std::get<0>(p);
-                        TypeDecl * td = std::get<1>(p);
                         newType->get_parameters().push_back( new TypeExpr( t->clone() ) );
-                        if ( env ) {
-                                // add bindings to the type environment.
-                                // xxx - This may not be sufficient, it may be necessary to rename type variables on StructInstType?
-                                env->add( td->get_name(), t->clone() );
-                        }
                 }
                 delete tupleType;
@@ -293 +268 @@
         }
 
-        Expression * TupleExprExpander::mutate( TupleExpr * tupleExpr ) {
-                // recursively expand sub-tuple-expressions
-                tupleExpr = safe_dynamic_cast<TupleExpr *>(Parent::mutate(tupleExpr));
+        Expression * TupleExprExpander::postmutate( TupleExpr * tupleExpr ) {
                 Type * result = tupleExpr->get_result();
                 std::list< Expression * > exprs = tupleExpr->get_exprs();
@@ -342 +315 @@
                 class ImpurityDetector : public Visitor {
                 public:
+                        ImpurityDetector( bool ignoreUnique ) : ignoreUnique( ignoreUnique ) {}
+
                         typedef Visitor Parent;
                         virtual void visit( ApplicationExpr * appExpr ) {
@@ -355 +330 @@
                                 maybeImpure = true;
                         }
-                        virtual void visit( __attribute__((unused)) UntypedExpr * untypedExpr ) { maybeImpure = true; }
+                        virtual void visit( UntypedExpr * ) { maybeImpure = true; }
+                        virtual void visit( UniqueExpr * unq ) {
+                                if ( ignoreUnique ) {
+                                        // bottom out at unique expression.
+                                        // The existence of a unique expression doesn't change the purity of an expression.
+                                        // That is, even if the wrapped expression is impure, the wrapper protects the rest of the expression.
+                                        return;
+                                }
+                                maybeAccept( unq->expr, *this );
+                        }
+
                         bool maybeImpure = false;
+                        bool ignoreUnique;
                 };
         } // namespace
 
         bool maybeImpure( Expression * expr ) {
-                ImpurityDetector detector;
+                ImpurityDetector detector( false );
+                expr->accept( detector );
+                return detector.maybeImpure;
+        }
+
+        bool maybeImpureIgnoreUnique( Expression * expr ) {
+                ImpurityDetector detector( true );
                 expr->accept( detector );
                 return detector.maybeImpure;