Changeset e0e9a0b for src/AST/Pass.impl.hpp

Timestamp:

Jun 27, 2019, 5:16:54 PM (5 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

7d0881c

Parents:

6be3b7d6

Message:

Somewhat deeper clone for types with forall qualifiers.

• Added WithForallSubstitutor? pass accessory to perform these changes
• modified copy constructors of ParameterizedType? to properly update children

File:

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

src/AST/Pass.impl.hpp

@@ -127 +127 @@
                         , decltype( node->accept(*this) )
                 >::type
-
         {
                 __pedantic_pass_assert( __visit_children() );
-                __pedantic_pass_assert( expr );
+                __pedantic_pass_assert( node );
 
                 static_assert( !std::is_base_of<ast::Expr, node_t>::value, "ERROR");
@@ -323 +322 @@
         }
 
+
+        template< typename pass_t >
+        template< typename node_t >
+        void ast::Pass< pass_t >::mutate_forall( const node_t *& node ) {
+                if ( auto subs = __pass::forall::subs( pass, 0 ) ) {
+                        // tracking TypeDecl substitution, full clone
+                        if ( node->forall.empty() ) return;
+
+                        node_t * mut = mutate( node );
+                        mut->forall = subs->clone( node->forall, *this );
+                        node = mut;
+                } else {
+                        // not tracking TypeDecl substitution, just mutate
+                        maybe_accept( node, &node_t::forall );
+                }
+        }
 }
 
@@ -1667 +1682 @@
         VISIT_START( node );
 
-        VISIT(
-                maybe_accept( node, &FunctionType::forall  );
+        VISIT({
+                guard_forall_subs forall_guard { *this, node };
+                mutate_forall( node );
                 maybe_accept( node, &FunctionType::returns );
                 maybe_accept( node, &FunctionType::params  );
-        )
+        })
 
         VISIT_END( Type, node );
@@ -1686 +1702 @@
         VISIT({
                 guard_symtab guard { *this };
-                maybe_accept( node, &StructInstType::forall );
+                guard_forall_subs forall_guard { *this, node };
+                mutate_forall( node );
                 maybe_accept( node, &StructInstType::params );
         })
@@ -1699 +1716 @@
         VISIT_START( node );
 
-        __pass::symtab::addStruct( pass, 0, node->name );
-
-        {
+        __pass::symtab::addUnion( pass, 0, node->name );
+
+        VISIT({
                 guard_symtab guard { *this };
-                maybe_accept( node, &UnionInstType::forall );
+                guard_forall_subs forall_guard { *this, node };
+                mutate_forall( node );
                 maybe_accept( node, &UnionInstType::params );
-        }
+        })
 
         VISIT_END( Type, node );
@@ -1716 +1734 @@
         VISIT_START( node );
 
-        VISIT(
-                maybe_accept( node, &EnumInstType::forall );
+        VISIT({
+                guard_forall_subs forall_guard { *this, node };
+                mutate_forall( node );
                 maybe_accept( node, &EnumInstType::params );
-        )
+        })
 
         VISIT_END( Type, node );
@@ -1730 +1749 @@
         VISIT_START( node );
 
-        VISIT(
-                maybe_accept( node, &TraitInstType::forall );
+        VISIT({
+                guard_forall_subs forall_guard { *this, node };
+                mutate_forall( node );
                 maybe_accept( node, &TraitInstType::params );
-        )
+        })
 
         VISIT_END( Type, node );
@@ -1745 +1765 @@
 
         VISIT(
-                maybe_accept( node, &TypeInstType::forall );
-                maybe_accept( node, &TypeInstType::params );
+                {
+                        guard_forall_subs forall_guard { *this, node };
+                        mutate_forall( node );
+                        maybe_accept( node, &TypeInstType::params );
+                }
+                // ensure that base re-bound if doing substitution
+                __pass::forall::replace( pass, 0, node );
         )