Changeset 24d6572 for src/AST/Pass.impl.hpp

Timestamp:

Jun 12, 2023, 2:45:32 PM (2 years ago)

Author:

Fangren Yu <f37yu@…>

Branches:

ast-experimental, master

Children:

62d62db

Parents:

34b4268 (diff), 251ce80 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into ast-experimental

File:

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

src/AST/Pass.impl.hpp

@@ -20 +20 @@
 #include <unordered_map>
 
+#include "AST/Copy.hpp"
 #include "AST/TranslationUnit.hpp"
 #include "AST/TypeSubstitution.hpp"
@@ -45 +46 @@
 
 #ifdef PEDANTIC_PASS_ASSERT
-#define __pedantic_pass_assert(...) assert (__VA_ARGS__)
+#define __pedantic_pass_assert(...) assert(__VA_ARGS__)
 #define __pedantic_pass_assertf(...) assertf(__VA_ARGS__)
 #else
@@ -124 +125 @@
                         return !new_val.empty();
                 }
-        }
-
-        template< typename node_t >
-        template< typename object_t, typename super_t, typename field_t >
-        void __pass::result1< node_t >::apply( object_t * object, field_t super_t::* field ) {
-                object->*field = value;
         }
 
@@ -233 +228 @@
 
                 return {true, compound};
-        }
-
-        template< template <class...> class container_t >
-        template< typename object_t, typename super_t, typename field_t >
-        void __pass::resultNstmt<container_t>::apply(object_t * object, field_t super_t::* field) {
-                auto & container = object->*field;
-                __pedantic_pass_assert( container.size() <= values.size() );
-
-                auto cit = enumerate(container).begin();
-
-                container_t<ptr<Stmt>> nvals;
-                for (delta & d : values) {
-                        if ( d.is_old ) {
-                                __pedantic_pass_assert( cit.idx <= d.old_idx );
-                                std::advance( cit, d.old_idx - cit.idx );
-                                nvals.push_back( std::move( (*cit).val) );
-                        } else {
-                                nvals.push_back( std::move(d.new_val) );
-                        }
-                }
-
-                container = std::move(nvals);
-        }
-
-        template< template <class...> class container_t >
-        template< template <class...> class incontainer_t >
-        void __pass::resultNstmt< container_t >::take_all( incontainer_t<ptr<Stmt>> * stmts ) {
-                if (!stmts || stmts->empty()) return;
-
-                std::transform(stmts->begin(), stmts->end(), std::back_inserter( values ),
-                        [](ast::ptr<ast::Stmt>& stmt) -> delta {
-                                return delta( stmt.release(), -1, false );
-                        });
-                stmts->clear();
-                differs = true;
-        }
-
-        template< template<class...> class container_t >
-        template< template<class...> class incontainer_t >
-        void __pass::resultNstmt< container_t >::take_all( incontainer_t<ptr<Decl>> * decls ) {
-                if (!decls || decls->empty()) return;
-
-                std::transform(decls->begin(), decls->end(), std::back_inserter( values ),
-                        [](ast::ptr<ast::Decl>& decl) -> delta {
-                                auto loc = decl->location;
-                                auto stmt = new DeclStmt( loc, decl.release() );
-                                return delta( stmt, -1, false );
-                        });
-                decls->clear();
-                differs = true;
         }
 
@@ -352 +297 @@
 
                 return new_kids;
-        }
-
-        template< template <class...> class container_t, typename node_t >
-        template< typename object_t, typename super_t, typename field_t >
-        void __pass::resultN<container_t, node_t>::apply(object_t * object, field_t super_t::* field) {
-                auto & container = object->*field;
-                __pedantic_pass_assert( container.size() == values.size() );
-
-                for(size_t i = 0; i < container.size(); i++) {
-                        // Take all the elements that are different in 'values'
-                        // and swap them into 'container'
-                        if( values[i] != nullptr ) swap(container[i], values[i]);
-                }
-
-                // Now the original containers should still have the unchanged values
-                // but also contain the new values
         }
 
@@ -836 +765 @@
                         if ( enterScope ) {
                                 __pass::symtab::enter(core, 0);
-                                __pass::scope::enter(core, 0);
                         }
                 }, [this, leaveScope = !this->atFunctionTop]() {
                         if ( leaveScope ) {
                                 __pass::symtab::leave(core, 0);
-                                __pass::scope::leave(core, 0);
                         }
                 });
@@ -1067 +994 @@
 
 //--------------------------------------------------------------------------
+// WhenClause
+template< typename core_t >
+const ast::WhenClause * ast::Pass< core_t >::visit( const ast::WhenClause * node ) {
+        VISIT_START( node );
+
+        if ( __visit_children() ) {
+                maybe_accept( node, &WhenClause::target );
+                maybe_accept( node, &WhenClause::stmt );
+                maybe_accept( node, &WhenClause::when_cond );
+        }
+
+        VISIT_END( WhenClause, node );
+}
+
+//--------------------------------------------------------------------------
 // WaitForStmt
 template< typename core_t >
@@ -1091 +1033 @@
 
         if ( __visit_children() ) {
-                maybe_accept( node, &WaitForClause::target_func );
+                maybe_accept( node, &WaitForClause::target );
                 maybe_accept( node, &WaitForClause::target_args );
                 maybe_accept( node, &WaitForClause::stmt );
-                maybe_accept( node, &WaitForClause::cond );
+                maybe_accept( node, &WaitForClause::when_cond );
         }
 
         VISIT_END( WaitForClause, node );
+}
+
+//--------------------------------------------------------------------------
+// WaitUntilStmt
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::WaitUntilStmt * node ) {
+        VISIT_START( node );
+
+        if ( __visit_children() ) {
+                maybe_accept( node, &WaitUntilStmt::clauses );
+                maybe_accept( node, &WaitUntilStmt::timeout_time );
+                maybe_accept( node, &WaitUntilStmt::timeout_stmt );
+                maybe_accept( node, &WaitUntilStmt::timeout_cond );
+                maybe_accept( node, &WaitUntilStmt::else_stmt );
+                maybe_accept( node, &WaitUntilStmt::else_cond );
+        }
+
+        VISIT_END( Stmt, node );
 }
 
@@ -2043 +2003 @@
         if ( __visit_children() ) {
                 maybe_accept( node, &TupleType::types );
-                maybe_accept( node, &TupleType::members );
         }
 
@@ -2205 +2164 @@
 }
 
+#undef __pedantic_pass_assertf
+#undef __pedantic_pass_assert
 #undef VISIT_START
 #undef VISIT_END