Changes in src/AST/Pass.impl.hpp [c570806:665f432]

File:

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

src/AST/Pass.impl.hpp

@@ -127 +127 @@
                         , decltype( node->accept(*this) )
                 >::type
+
         {
                 __pedantic_pass_assert( __visit_children() );
-                __pedantic_pass_assert( node );
+                __pedantic_pass_assert( expr );
 
                 static_assert( !std::is_base_of<ast::Expr, node_t>::value, "ERROR");
@@ -322 +323 @@
         }
 
-
-        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 );
-                }
-        }
 }
 
@@ -444 +429 @@
                         guard_symtab guard { *this };
                         // implicit add __func__ identifier as specified in the C manual 6.4.2.2
-                        static ast::ptr< ast::ObjectDecl > func{ new ast::ObjectDecl{ 
-                                CodeLocation{}, "__func__",
-                                new ast::ArrayType{
-                                        new ast::BasicType{ ast::BasicType::Char, ast::CV::Const },
+                        static ast::ObjectDecl func(
+                                node->location, "__func__",
+                                new ast::ArrayType(
+                                        new ast::BasicType( ast::BasicType::Char, ast::CV::Qualifiers( ast::CV::Const ) ),
                                         nullptr, VariableLen, DynamicDim
-                                }
-                        } };
-                        __pass::symtab::addId( pass, 0, func );
+                                )
+                        );
+                        __pass::symtab::addId( pass, 0, &func );
                         VISIT(
                                 maybe_accept( node, &FunctionDecl::type );
@@ -625 +610 @@
         VISIT({
                 // do not enter a new scope if inFunction is true - needs to check old state before the assignment
-                auto guard1 = makeFuncGuard( [this, inFunctionCpy = this->inFunction]() {
-                        if ( ! inFunctionCpy ) __pass::symtab::enter(pass, 0);
-                }, [this, inFunctionCpy = this->inFunction]() {
-                        if ( ! inFunctionCpy ) __pass::symtab::leave(pass, 0);
+                auto guard1 = makeFuncGuard( [this, inFunction = this->inFunction]() {
+                        if ( ! inFunction ) __pass::symtab::enter(pass, 0);
+                }, [this, inFunction = this->inFunction]() {
+                        if ( ! inFunction ) __pass::symtab::leave(pass, 0);
                 });
                 ValueGuard< bool > guard2( inFunction );
@@ -953 +938 @@
         // For now this isn't visited, it is unclear if this causes problem
         // if all tests are known to pass, remove this code
-        VISIT(
-                maybe_accept( node, &ImplicitCtorDtorStmt::callStmt );
-        )
+        // VISIT(
+        //      maybe_accept( node, &ImplicitCtorDtorStmt::callStmt );
+        // )
 
         VISIT_END( Stmt, node );
@@ -1315 +1300 @@
                         maybe_accept( node, &AsmExpr::result );
                 }
-                maybe_accept( node, &AsmExpr::inout      );
                 maybe_accept( node, &AsmExpr::constraint );
                 maybe_accept( node, &AsmExpr::operand    );
@@ -1682 +1666 @@
         VISIT_START( node );
 
-        VISIT({
-                guard_forall_subs forall_guard { *this, node };
-                mutate_forall( node );
+        VISIT(
+                maybe_accept( node, &FunctionType::forall  );
                 maybe_accept( node, &FunctionType::returns );
                 maybe_accept( node, &FunctionType::params  );
-        })
+        )
 
         VISIT_END( Type, node );
@@ -1702 +1685 @@
         VISIT({
                 guard_symtab guard { *this };
-                guard_forall_subs forall_guard { *this, node };
-                mutate_forall( node );
+                maybe_accept( node, &StructInstType::forall );
                 maybe_accept( node, &StructInstType::params );
         })
@@ -1716 +1698 @@
         VISIT_START( node );
 
-        __pass::symtab::addUnion( pass, 0, node->name );
-
-        VISIT({
+        __pass::symtab::addStruct( pass, 0, node->name );
+
+        {
                 guard_symtab guard { *this };
-                guard_forall_subs forall_guard { *this, node };
-                mutate_forall( node );
+                maybe_accept( node, &UnionInstType::forall );
                 maybe_accept( node, &UnionInstType::params );
-        })
+        }
 
         VISIT_END( Type, node );
@@ -1734 +1715 @@
         VISIT_START( node );
 
-        VISIT({
-                guard_forall_subs forall_guard { *this, node };
-                mutate_forall( node );
+        VISIT(
+                maybe_accept( node, &EnumInstType::forall );
                 maybe_accept( node, &EnumInstType::params );
-        })
+        )
 
         VISIT_END( Type, node );
@@ -1749 +1729 @@
         VISIT_START( node );
 
-        VISIT({
-                guard_forall_subs forall_guard { *this, node };
-                mutate_forall( node );
+        VISIT(
+                maybe_accept( node, &TraitInstType::forall );
                 maybe_accept( node, &TraitInstType::params );
-        })
+        )
 
         VISIT_END( Type, node );
@@ -1765 +1744 @@
 
         VISIT(
-                {
-                        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 );
+                maybe_accept( node, &TypeInstType::forall );
+                maybe_accept( node, &TypeInstType::params );
         )
 
@@ -1920 +1894 @@
                                 guard_symtab guard { *this };
                                 auto new_node = p.second->accept( *this );
-                                if (new_node != p.second) mutated = true;
+                                if (new_node != p.second) mutated = false;
                                 new_map.insert({ p.first, new_node });
                         }
@@ -1936 +1910 @@
                                 guard_symtab guard { *this };
                                 auto new_node = p.second->accept( *this );
-                                if (new_node != p.second) mutated = true;
+                                if (new_node != p.second) mutated = false;
                                 new_map.insert({ p.first, new_node });
                         }