Changes in / [c9b3a41:000ff2c]

Files:

• doc/papers/general/evaluation/cfa-pair.c (modified) (5 diffs)
• doc/papers/general/evaluation/cfa-stack.c (modified) (3 diffs)
• src/InitTweak/FixInit.cc (modified) (3 diffs)
• src/ResolvExpr/Resolver.cc (modified) (2 diffs)
• src/ResolvExpr/TypeEnvironment.cc (modified) (1 diff)
• src/ResolvExpr/TypeEnvironment.h (modified) (1 diff)
• src/SynTree/TypeSubstitution.h (modified) (1 diff)
• src/Tuples/TupleAssignment.cc (modified) (2 diffs)

doc/papers/general/evaluation/cfa-pair.c

@@ -2 +2 @@
 #include "fstream"
 
-forall(otype R, otype S 
+forall(otype R, otype S
         | { int ?==?(R, R); int ?<?(R, R); int ?<?(S, S); })
 int ?<?(pair(R, S) p, pair(R, S) q) {
@@ -8 +8 @@
 }
 
-forall(otype R, otype S 
+forall(otype R, otype S
         | { int ?==?(R, R); int ?<?(R, R); int ?<=?(S, S); })
 int ?<=?(pair(R, S) p, pair(R, S) q) {
@@ -24 +24 @@
 }
 
-forall(otype R, otype S 
+forall(otype R, otype S
         | { int ?==?(R, R); int ?>?(R, R); int ?>?(S, S); })
 int ?>?(pair(R, S) p, pair(R, S) q) {
@@ -30 +30 @@
 }
 
-forall(otype R, otype S 
+forall(otype R, otype S
         | { int ?==?(R, R); int ?>?(R, R); int ?>=?(S, S); })
 int ?>=?(pair(R, S) p, pair(R, S) q) {
@@ -37 +37 @@
 
 forall(otype R, otype S)
-forall(dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, pair(R, S) ); })
+forall(dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, R ); ostype & ?|?( ostype &, S );  })
 ostype & ?|?( ostype & os, pair(R, S) p ) {
         return os | '[' | p.first | ',' | p.second | ']';

doc/papers/general/evaluation/cfa-stack.c

@@ -16 +16 @@
         stack_node(T) ** crnt = &s.head;
         for ( stack_node(T) * next = t.head; next; next = next->next ) {
-            *crnt = new( next->value, 0 );
+                // *crnt = new( next->value, 0 );
+                stack_node(T)* new_node = ((stack_node(T)*)malloc());
+                (*new_node){ next->value }; /***/
+                *crnt = new_node;
                 stack_node(T) * acrnt = *crnt;
                 crnt = &acrnt->next;
@@ -35 +38 @@
 
 forall(otype T) void push( stack(T) & s, T value ) {
-    s.head = new( value, s.head );
+        // s.head = new( value, s.head );
+        stack_node(T)* new_node = ((stack_node(T)*)malloc());
+        (*new_node){ value, s.head }; /***/
+        s.head = new_node;
 }
 
@@ -42 +48 @@
         s.head = n->next;
         T v = n->value;
-//      ^n{};
-        free( n );
+        delete( n );
         return v;
 }

src/InitTweak/FixInit.cc

@@ -187 +187 @@
                 };
 
-                class FixCopyCtors final : public WithStmtsToAdd, public WithShortCircuiting, public WithVisitorRef<FixCopyCtors> {
+                class FixCopyCtors final : public WithStmtsToAdd, public WithShortCircuiting, public WithVisitorRef<FixCopyCtors>, public WithTypeSubstitution {
                   public:
                         FixCopyCtors( UnqCount & unqCount ) : unqCount( unqCount ){}
@@ -448 +448 @@
                         ResolvExpr::findVoidExpression( resolved, indexer );
                         assert( resolved );
-                        if ( resolved->get_env() ) {
+                        if ( resolved->env ) {
                                 // Extract useful information and discard new environments. Keeping them causes problems in PolyMutator passes.
-                                env->add( *resolved->get_env() );
-                                delete resolved->get_env();
-                                resolved->set_env( nullptr );
+                                env->add( *resolved->env );
+                                delete resolved->env;
+                                resolved->env = nullptr;
                         } // if
                         delete stmt;
@@ -636 +636 @@
                                 // take relevant bindings from environment
                                 assert( ! dtor->env );
-                                dtor->env =  TypeSubstitution::newFromExpr( dtor, impCpCtorExpr->env );
+                                dtor->env =  maybeClone( env );
                                 stmtsToAddAfter.push_back( new ExprStmt( dtor ) );
                         } // for

src/ResolvExpr/Resolver.cc

@@ -788 +788 @@
                 stmtExpr->accept( resolver );
                 stmtExpr->computeResult();
+                // xxx - aggregate the environments from all statements? Possibly in AlternativeFinder instead?
         }
 
@@ -793 +794 @@
                 visit_children = false;
                 // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit
-                maybeAccept( ctorInit->get_ctor(), *visitor );
-                maybeAccept( ctorInit->get_dtor(), *visitor );
+                maybeAccept( ctorInit->ctor, *visitor );
+                maybeAccept( ctorInit->dtor, *visitor );
 
                 // found a constructor - can get rid of C-style initializer
-                delete ctorInit->get_init();
-                ctorInit->set_init( NULL );
+                delete ctorInit->init;
+                ctorInit->init = nullptr;
 
                 // intrinsic single parameter constructors and destructors do nothing. Since this was
                 // implicitly generated, there's no way for it to have side effects, so get rid of it
                 // to clean up generated code.
-                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->get_ctor() ) ) {
-                        delete ctorInit->get_ctor();
-                        ctorInit->set_ctor( NULL );
-                }
-
-                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->get_dtor() ) ) {
-                        delete ctorInit->get_dtor();
-                        ctorInit->set_dtor( NULL );
+                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->ctor ) ) {
+                        delete ctorInit->ctor;
+                        ctorInit->ctor = nullptr;
+                }
+
+                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->dtor ) ) {
+                        delete ctorInit->dtor;
+                        ctorInit->dtor = nullptr;
                 }
 

src/ResolvExpr/TypeEnvironment.cc

@@ -118 +118 @@
                         env.push_back( newClass );
                 } // for
+        }
+
+        void TypeEnvironment::add( const TypeSubstitution & sub ) {
+                EqvClass newClass;
+                for ( auto p : sub ) {
+                        newClass.vars.insert( p.first );
+                        newClass.type = p.second->clone();
+                        newClass.allowWidening = false;
+                        // Minimal assumptions. Not technically correct, but might be good enough, and
+                        // is the best we can do at the moment since information is lost in the
+                        // transition to TypeSubstitution
+                        newClass.data = TypeDecl::Data{ TypeDecl::Dtype, false };
+                        add( newClass );
+                }
         }
 

src/ResolvExpr/TypeEnvironment.h

@@ -76 +76 @@
                 void add( const EqvClass &eqvClass );
                 void add( const Type::ForallList &tyDecls );
+                void add( const TypeSubstitution & sub );
                 template< typename SynTreeClass > int apply( SynTreeClass *&type ) const;
                 template< typename SynTreeClass > int applyFree( SynTreeClass *&type ) const;

src/SynTree/TypeSubstitution.h

@@ -82 +82 @@
         TypeEnvType typeEnv;
         VarEnvType varEnv;
+
+  public:
+        // has to come after declaration of typeEnv
+        auto begin()       -> decltype( typeEnv.begin() ) { return typeEnv.begin(); }
+        auto   end()       -> decltype( typeEnv.  end() ) { return typeEnv.  end(); }
+        auto begin() const -> decltype( typeEnv.begin() ) { return typeEnv.begin(); }
+        auto   end() const -> decltype( typeEnv.  end() ) { return typeEnv.  end(); }
 };
 

src/Tuples/TupleAssignment.cc

@@ -281 +281 @@
         }
 
-        // removes environments from subexpressions within statement exprs, which could throw off later passes like those in Box which rely on PolyMutator.
+        // removes environments from subexpressions within statement exprs, which could throw off later passes like those in Box which rely on PolyMutator, and adds the bindings to the compositeEnv
         // 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 {
                 void previsit( ExprStmt * stmt ) {
-                        delete stmt->expr->env;
-                        stmt->expr->env = nullptr;
-                }
+                        assert( compositeEnv );
+                        if ( stmt->expr->env ) {
+                                compositeEnv->add( *stmt->expr->env );
+                                delete stmt->expr->env;
+                                stmt->expr->env = nullptr;
+                        }
+                }
+
+                ResolvExpr::TypeEnvironment * compositeEnv = nullptr;
         };
 
@@ -300 +305 @@
                         ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object
                         PassVisitor<EnvRemover> rm; // remove environments from subexpressions of StmtExprs
+                        rm.pass.compositeEnv = &compositeEnv;
                         ctorInit->accept( rm );
                 }