Changes in src/AST/Pass.impl.hpp [3e5dd913:361bf01]

File:

• src/AST/Pass.impl.hpp (modified) (5 diffs)

src/AST/Pass.impl.hpp

@@ -367 +367 @@
         }
 
+
+        template< typename core_t >
+        template< typename node_t >
+        void ast::Pass< core_t >::mutate_forall( const node_t *& node ) {
+                if ( auto subs = __pass::forall::subs( core, 0 ) ) {
+                        // tracking TypeDecl substitution, full clone
+                        if ( node->forall.empty() ) return;
+
+                        node_t * mut = __pass::mutate<core_t>( node );
+                        mut->forall = subs->clone( node->forall, *this );
+                        node = mut;
+                } else {
+                        // not tracking TypeDecl substitution, just mutate
+                        maybe_accept( node, &node_t::forall );
+                }
+        }
 }
 
@@ -488 +504 @@
                         __pass::symtab::addId( core, 0, func );
                         VISIT(
-                                // parameter declarations
+                                // parameter declarations are now directly here
                                 maybe_accept( node, &FunctionDecl::params );
                                 maybe_accept( node, &FunctionDecl::returns );
-                                // type params and assertions
-                                maybe_accept( node, &FunctionDecl::type_params );
-                                maybe_accept( node, &FunctionDecl::assertions );
+                                // foralls are still in function type
+                                maybe_accept( node, &FunctionDecl::type );
                                 // First remember that we are now within a function.
                                 ValueGuard< bool > oldInFunction( inFunction );
@@ -1743 +1758 @@
 
         VISIT({
-                // guard_forall_subs forall_guard { *this, node };
-                // mutate_forall( node );
-                maybe_accept( node, &FunctionType::assertions );
+                guard_forall_subs forall_guard { *this, node };
+                mutate_forall( node );
                 maybe_accept( node, &FunctionType::returns );
                 maybe_accept( node, &FunctionType::params  );
@@ -1967 +1981 @@
                 {
                         bool mutated = false;
-                        std::unordered_map< ast::TypeInstType::TypeEnvKey, ast::ptr< ast::Type > > new_map;
+                        std::unordered_map< std::string, ast::ptr< ast::Type > > new_map;
                         for ( const auto & p : node->typeEnv ) {
                                 guard_symtab guard { *this };
@@ -1980 +1994 @@
                         }
                 }
+
+                {
+                        bool mutated = false;
+                        std::unordered_map< std::string, ast::ptr< ast::Expr > > new_map;
+                        for ( const auto & p : node->varEnv ) {
+                                guard_symtab guard { *this };
+                                auto new_node = p.second->accept( *this );
+                                if (new_node != p.second) mutated = true;
+                                new_map.insert({ p.first, new_node });
+                        }
+                        if (mutated) {
+                                auto new_node = __pass::mutate<core_t>( node );
+                                new_node->varEnv.swap( new_map );
+                                node = new_node;
+                        }
+                }
         )