Changeset 24d6572 for src/AST

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

Location:

src/AST

Files:

• Attribute.hpp (modified) (1 diff)
• Convert.cpp (modified) (8 diffs)
• Create.cpp (modified) (1 diff)
• Decl.cpp (modified) (3 diffs)
• Decl.hpp (modified) (6 diffs)
• Expr.cpp (modified) (1 diff)
• Expr.hpp (modified) (4 diffs)
• Fwd.hpp (modified) (3 diffs)
• Init.hpp (modified) (1 diff)
• Inspect.cpp (modified) (2 diffs)
• Inspect.hpp (modified) (2 diffs)
• Node.cpp (modified) (1 diff)
• Node.hpp (modified) (2 diffs)
• ParseNode.hpp (modified) (1 diff)
• Pass.hpp (modified) (4 diffs)
• Pass.impl.hpp (modified) (10 diffs)
• Pass.proto.hpp (modified) (1 diff)
• Print.cpp (modified) (16 diffs)
• Print.hpp (modified) (2 diffs)
• Stmt.hpp (modified) (8 diffs)
• SymbolTable.cpp (modified) (10 diffs)
• SymbolTable.hpp (modified) (1 diff)
• TranslationUnit.hpp (modified) (3 diffs)
• Type.cpp (modified) (2 diffs)
• Type.hpp (modified) (3 diffs)
• TypeEnvironment.cpp (modified) (10 diffs)
• TypeEnvironment.hpp (modified) (5 diffs)
• TypeSubstitution.cpp (modified) (3 diffs)
• TypeSubstitution.hpp (modified) (4 diffs)
• Visitor.hpp (modified) (1 diff)
• porting.md (modified) (3 diffs)

src/AST/Attribute.hpp

@@ -27 +27 @@
 class Expr;
 
+/// An entry in an attribute list: `__attribute__(( ... ))`
 class Attribute final : public Node {
 public:

src/AST/Convert.cpp

@@ -559 +559 @@
                 auto stmt = new SuspendStmt();
                 stmt->then   = get<CompoundStmt>().accept1( node->then   );
-                switch(node->type) {
+                switch (node->kind) {
                         case ast::SuspendStmt::None     : stmt->type = SuspendStmt::None     ; break;
                         case ast::SuspendStmt::Coroutine: stmt->type = SuspendStmt::Coroutine; break;
@@ -565 +565 @@
                 }
                 return stmtPostamble( stmt, node );
+        }
+
+    const ast::WhenClause * visit( const ast::WhenClause * node ) override final {
+                // There is no old-AST WhenClause, so this should never be called.
+                assert( !node );
+                return nullptr;
         }
 
@@ -573 +579 @@
                 for ( auto clause : node->clauses ) {
                         stmt->clauses.push_back({{
-                                        get<Expression>().accept1( clause->target_func ),
+                                        get<Expression>().accept1( clause->target ),
                                         get<Expression>().acceptL( clause->target_args ),
                                 },
                                 get<Statement>().accept1( clause->stmt ),
-                                get<Expression>().accept1( clause->cond ),
+                                get<Expression>().accept1( clause->when_cond ),
                         });
                 }
@@ -594 +600 @@
         const ast::WaitForClause * visit( const ast::WaitForClause * node ) override final {
                 // There is no old-AST WaitForClause, so this should never be called.
+                assert( !node );
+                return nullptr;
+        }
+
+    const ast::Stmt * visit( const ast::WaitUntilStmt * node ) override final {
+        // There is no old-AST WaitUntilStmt, so this should never be called.
                 assert( !node );
                 return nullptr;
@@ -1683 +1695 @@
                         GET_ACCEPT_V(attributes, Attribute),
                         { old->get_funcSpec().val },
-                        old->type->isVarArgs
+                        (old->type->isVarArgs) ? ast::VariableArgs : ast::FixedArgs
                 };
 
@@ -1989 +2001 @@
                         GET_ACCEPT_1(else_, Stmt),
                         GET_ACCEPT_V(initialization, Stmt),
-                        old->isDoWhile,
+                        (old->isDoWhile) ? ast::DoWhile : ast::While,
                         GET_LABELS_V(old->labels)
                 );
@@ -2131 +2143 @@
         virtual void visit( const SuspendStmt * old ) override final {
                 if ( inCache( old ) ) return;
-                ast::SuspendStmt::Type type;
+                ast::SuspendStmt::Kind type;
                 switch (old->type) {
                         case SuspendStmt::Coroutine: type = ast::SuspendStmt::Coroutine; break;
@@ -2158 +2170 @@
                         auto clause = new ast::WaitForClause( old->location );
 
-                        clause->target_func = GET_ACCEPT_1(clauses[i].target.function, Expr);
+                        clause->target = GET_ACCEPT_1(clauses[i].target.function, Expr);
                         clause->target_args = GET_ACCEPT_V(clauses[i].target.arguments, Expr);
                         clause->stmt = GET_ACCEPT_1(clauses[i].statement, Stmt);
-                        clause->cond = GET_ACCEPT_1(clauses[i].condition, Expr);
+                        clause->when_cond = GET_ACCEPT_1(clauses[i].condition, Expr);
 
                         stmt->clauses.push_back( clause );

src/AST/Create.cpp

@@ -20 +20 @@
 #include "AST/Decl.hpp"
 #include "AST/Type.hpp"
+#include "Common/Iterate.hpp"
 
 namespace ast {

src/AST/Decl.cpp

@@ -20 +20 @@
 #include <unordered_map>
 
-#include "Common/utility.h"
+#include "Common/Eval.h"       // for eval
 
 #include "Fwd.hpp"             // for UniqueId
@@ -57 +57 @@
         std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
         CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
-        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
+        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, ArgumentFlag isVarArgs )
 : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ),
         type_params(std::move(forall)), assertions(),
         params(std::move(params)), returns(std::move(returns)), stmts( stmts ) {
-        FunctionType * ftype = new FunctionType(static_cast<ArgumentFlag>(isVarArgs));
+        FunctionType * ftype = new FunctionType( isVarArgs );
         for (auto & param : this->params) {
                 ftype->params.emplace_back(param->get_type());
@@ -81 +81 @@
         std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
         CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
-        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
+        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, ArgumentFlag isVarArgs )
 : DeclWithType( location, name, storage, linkage, std::move(attrs), fs ),
                 type_params( std::move( forall) ), assertions( std::move( assertions ) ),
                 params( std::move(params) ), returns( std::move(returns) ),
                 type( nullptr ), stmts( stmts ) {
-        FunctionType * type = new FunctionType( (isVarArgs) ? VariableArgs : FixedArgs );
+        FunctionType * type = new FunctionType( isVarArgs );
         for ( auto & param : this->params ) {
                 type->params.emplace_back( param->get_type() );

src/AST/Decl.hpp

@@ -10 +10 @@
 // Created On       : Thu May 9 10:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu Nov 24  9:44:00 2022
-// Update Count     : 34
+// Last Modified On : Wed Apr  5 10:42:00 2023
+// Update Count     : 35
 //
 
@@ -122 +122 @@
 };
 
+/// Function variable arguments flag
+enum ArgumentFlag { FixedArgs, VariableArgs };
+
 /// Object declaration `int foo()`
 class FunctionDecl : public DeclWithType {
@@ -144 +147 @@
                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
-                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, ArgumentFlag isVarArgs = FixedArgs );
 
         FunctionDecl( const CodeLocation & location, const std::string & name,
@@ -150 +153 @@
                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
-                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, ArgumentFlag isVarArgs = FixedArgs );
 
         const Type * get_type() const override;
@@ -313 +316 @@
 public:
         bool isTyped; // isTyped indicated if the enum has a declaration like:
-        // enum (type_optional) Name {...} 
+        // enum (type_optional) Name {...}
         ptr<Type> base; // if isTyped == true && base.get() == nullptr, it is a "void" type enum
         enum class EnumHiding { Visible, Hide } hide;
@@ -371 +374 @@
 };
 
+/// Assembly declaration: `asm ... ( "..." : ... )`
 class AsmDecl : public Decl {
 public:

src/AST/Expr.cpp

@@ -30 +30 @@
 #include "Common/SemanticError.h"
 #include "GenPoly/Lvalue.h"        // for referencesPermissable
-#include "ResolvExpr/typeops.h"    // for extractResultType
+#include "ResolvExpr/Unify.h"      // for extractResultType
 #include "Tuples/Tuples.h"         // for makeTupleType
 

src/AST/Expr.hpp

@@ -256 +256 @@
 };
 
+/// A name qualified by a namespace or type.
 class QualifiedNameExpr final : public Expr {
 public:
@@ -261 +262 @@
         std::string name;
 
-        QualifiedNameExpr( const CodeLocation & loc, const Decl * d, const std::string & n ) 
+        QualifiedNameExpr( const CodeLocation & loc, const Decl * d, const std::string & n )
         : Expr( loc ), type_decl( d ), name( n ) {}
 
@@ -631 +632 @@
 };
 
+/// A name that refers to a generic dimension parameter.
 class DimensionExpr final : public Expr {
 public:
@@ -920 +922 @@
 };
 
-
 }
 

src/AST/Fwd.hpp

@@ -15 +15 @@
 
 #pragma once
+
+template<typename> struct bitfield;
 
 #include "AST/Node.hpp"
@@ -56 +58 @@
 class FinallyClause;
 class SuspendStmt;
+class WhenClause;
 class WaitForStmt;
 class WaitForClause;
+class WaitUntilStmt;
 class WithStmt;
 class DeclStmt;
@@ -147 +151 @@
 class TranslationGlobal;
 
+// For the following types, only use the using type.
+namespace CV {
+        struct qualifier_flags;
+        using Qualifiers = bitfield<qualifier_flags>;
 }
+namespace Function {
+        struct spec_flags;
+        using Specs = bitfield<spec_flags>;
+}
+namespace Storage {
+        struct class_flags;
+        using Classes = bitfield<class_flags>;
+}
+namespace Linkage {
+        struct spec_flags;
+        using Spec = bitfield<spec_flags>;
+}
+
+}

src/AST/Init.hpp

@@ -117 +117 @@
         ptr<Init> init;
 
-        ConstructorInit( 
+        ConstructorInit(
                 const CodeLocation & loc, const Stmt * ctor, const Stmt * dtor, const Init * init )
         : Init( loc, MaybeConstruct ), ctor( ctor ), dtor( dtor ), init( init ) {}

src/AST/Inspect.cpp

@@ -10 +10 @@
 // Created On       : Fri Jun 24 13:16:31 2022
 // Last Modified By : Andrew Beach
-// Last Modified On : Mon Oct  3 11:04:00 2022
-// Update Count     : 3
+// Last Modified On : Fri Apr 14 15:09:00 2023
+// Update Count     : 4
 //
 
@@ -168 +168 @@
 }
 
+bool isUnnamedBitfield( const ast::ObjectDecl * obj ) {
+        return obj && obj->name.empty() && obj->bitfieldWidth;
+}
+
 } // namespace ast

src/AST/Inspect.hpp

@@ -10 +10 @@
 // Created On       : Fri Jun 24 13:16:31 2022
 // Last Modified By : Andrew Beach
-// Last Modified On : Thr Sep 22 13:44:00 2022
-// Update Count     : 2
+// Last Modified On : Fri Apr 14 15:09:00 2023
+// Update Count     : 3
 //
 
@@ -38 +38 @@
 const ApplicationExpr * isIntrinsicCallExpr( const Expr * expr );
 
+/// Returns true if obj's name is the empty string and it has a bitfield width.
+bool isUnnamedBitfield( const ObjectDecl * obj );
+
 }

src/AST/Node.cpp

@@ -174 +174 @@
 template class ast::ptr_base< ast::FinallyClause, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::FinallyClause, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::WhenClause, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::WhenClause, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::WaitForClause, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::WaitForClause, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::WaitUntilStmt, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::WaitUntilStmt, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::WithStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::WithStmt, ast::Node::ref_type::strong >;

src/AST/Node.hpp

@@ -19 +19 @@
 #include <cstddef>     // for nullptr_t
 #include <iosfwd>
-#include <type_traits> // for remove_reference
 
 #include "Common/ErrorObjects.h"  // for SemanticErrorException
@@ -36 +35 @@
         Node(const Node&) : strong_count(0), weak_count(0) {}
         Node(Node&&) : strong_count(0), weak_count(0) {}
-        Node& operator= (const Node&) = delete;
-        Node& operator= (Node&&) = delete;
+        Node& operator=(const Node&) = delete;
+        Node& operator=(Node&&) = delete;
         virtual ~Node() {}
 

src/AST/ParseNode.hpp

@@ -40 +40 @@
         template<typename node_t>
         friend node_t * mutate(const node_t * node);
+        template<typename node_t>
+        friend node_t * shallowCopy(const node_t * node);
 };
 

src/AST/Pass.hpp

@@ -66 +66 @@
 //
 // Other Special Members:
+// | beginScope            - A method with no parameters or return value, called each time the
+//                           visitor enters a block.
+// | endScope              - A method with no parameters or return value, called each time the
+//                           visitor leaves a block.
 // | result                - Either a method that takes no parameters or a field. If a method (or
 //                           callable field) get_result calls it, otherwise the value is returned.
@@ -82 +86 @@
         {
                 // After the pass is constructed, check if it wants the have a pointer to the wrapping visitor
-                type * const * visitor = __pass::visitor(core, 0);
-                if(visitor) {
+                type * const * visitor = __pass::visitor( core, 0 );
+                if ( visitor ) {
                         *const_cast<type **>( visitor ) = this;
                 }
@@ -94 +98 @@
 
         /// If the core defines a result, call it if possible, otherwise return it.
-        inline auto get_result() -> decltype( __pass::get_result( core, '0' ) ) {
-                return __pass::get_result( core, '0' );
+        inline auto get_result() -> decltype( __pass::result::get( core, '0' ) ) {
+                return __pass::result::get( core, '0' );
         }
 
@@ -158 +162 @@
         const ast::FinallyClause *    visit( const ast::FinallyClause        * ) override final;
         const ast::Stmt *             visit( const ast::SuspendStmt          * ) override final;
+    const ast::WhenClause *       visit( const ast::WhenClause           * ) override final;
         const ast::Stmt *             visit( const ast::WaitForStmt          * ) override final;
         const ast::WaitForClause *    visit( const ast::WaitForClause        * ) override final;
+    const ast::Stmt *             visit( const ast::WaitUntilStmt        * ) override final;
         const ast::Decl *             visit( const ast::WithStmt             * ) override final;
         const ast::NullStmt *         visit( const ast::NullStmt             * ) override final;

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

src/AST/Pass.proto.hpp

@@ -17 +17 @@
 // IWYU pragma: private, include "Pass.hpp"
 
+#include "Common/Iterate.hpp"
 #include "Common/Stats/Heap.h"
-
 namespace ast {
-template<typename core_t>
-class Pass;
-
-class TranslationUnit;
-
-struct PureVisitor;
-
-template<typename node_t>
-node_t * deepCopy( const node_t * localRoot );
-
-namespace __pass {
-        typedef std::function<void( void * )> cleanup_func_t;
-        typedef std::function<void( cleanup_func_t, void * )> at_cleanup_t;
-
-
-        // boolean reference that may be null
-        // either refers to a boolean value or is null and returns true
-        class bool_ref {
-        public:
-                bool_ref() = default;
-                ~bool_ref() = default;
-
-                operator bool() { return m_ref ? *m_ref : true; }
-                bool operator=( bool val ) { assert(m_ref); return *m_ref = val; }
-
-        private:
-
-                friend class visit_children_guard;
-
-                bool * set( bool * val ) {
-                        bool * prev = m_ref;
-                        m_ref = val;
-                        return prev;
-                }
-
-                bool * m_ref = nullptr;
+        template<typename core_t> class Pass;
+        class TranslationUnit;
+        struct PureVisitor;
+        template<typename node_t> node_t * deepCopy( const node_t * );
+}
+
+#ifdef PEDANTIC_PASS_ASSERT
+#define __pedantic_pass_assert(...) assert(__VA_ARGS__)
+#define __pedantic_pass_assertf(...) assertf(__VA_ARGS__)
+#else
+#define __pedantic_pass_assert(...)
+#define __pedantic_pass_assertf(...)
+#endif
+
+namespace ast::__pass {
+
+typedef std::function<void( void * )> cleanup_func_t;
+typedef std::function<void( cleanup_func_t, void * )> at_cleanup_t;
+
+// boolean reference that may be null
+// either refers to a boolean value or is null and returns true
+class bool_ref {
+public:
+        bool_ref() = default;
+        ~bool_ref() = default;
+
+        operator bool() { return m_ref ? *m_ref : true; }
+        bool operator=( bool val ) { assert(m_ref); return *m_ref = val; }
+
+private:
+
+        friend class visit_children_guard;
+
+        bool * set( bool * val ) {
+                bool * prev = m_ref;
+                m_ref = val;
+                return prev;
+        }
+
+        bool * m_ref = nullptr;
+};
+
+// Implementation of the guard value
+// Created inside the visit scope
+class guard_value {
+public:
+        /// Push onto the cleanup
+        guard_value( at_cleanup_t * at_cleanup ) {
+                if( at_cleanup ) {
+                        *at_cleanup = [this]( cleanup_func_t && func, void* val ) {
+                                push( std::move( func ), val );
+                        };
+                }
+        }
+
+        ~guard_value() {
+                while( !cleanups.empty() ) {
+                        auto& cleanup = cleanups.top();
+                        cleanup.func( cleanup.val );
+                        cleanups.pop();
+                }
+        }
+
+        void push( cleanup_func_t && func, void* val ) {
+                cleanups.emplace( std::move(func), val );
+        }
+
+private:
+        struct cleanup_t {
+                cleanup_func_t func;
+                void * val;
+
+                cleanup_t( cleanup_func_t&& func, void * val ) : func(func), val(val) {}
         };
 
-        // Implementation of the guard value
-        // Created inside the visit scope
-        class guard_value {
-        public:
-                /// Push onto the cleanup
-                guard_value( at_cleanup_t * at_cleanup ) {
-                        if( at_cleanup ) {
-                                *at_cleanup = [this]( cleanup_func_t && func, void* val ) {
-                                        push( std::move( func ), val );
-                                };
+        std::stack< cleanup_t, std::vector<cleanup_t> > cleanups;
+};
+
+// Guard structure implementation for whether or not children should be visited
+class visit_children_guard {
+public:
+
+        visit_children_guard( bool_ref * ref )
+                : m_val ( true )
+                , m_prev( ref ? ref->set( &m_val ) : nullptr )
+                , m_ref ( ref )
+        {}
+
+        ~visit_children_guard() {
+                if( m_ref ) {
+                        m_ref->set( m_prev );
+                }
+        }
+
+        operator bool() { return m_val; }
+
+private:
+        bool       m_val;
+        bool     * m_prev;
+        bool_ref * m_ref;
+};
+
+/// "Short hand" to check if this is a valid previsit function
+/// Mostly used to make the static_assert look (and print) prettier
+template<typename core_t, typename node_t>
+struct is_valid_previsit {
+        using ret_t = decltype( std::declval<core_t*>()->previsit( std::declval<const node_t *>() ) );
+
+        static constexpr bool value = std::is_void< ret_t >::value ||
+                std::is_base_of<const node_t, typename std::remove_pointer<ret_t>::type >::value;
+};
+
+/// The result is a single node.
+template< typename node_t >
+struct result1 {
+        bool differs = false;
+        const node_t * value = nullptr;
+
+        template< typename object_t, typename super_t, typename field_t >
+        void apply( object_t * object, field_t super_t::* field ) {
+                object->*field = value;
+        }
+};
+
+/// The result is a container of statements.
+template< template<class...> class container_t >
+struct resultNstmt {
+        /// The delta/change on a single node.
+        struct delta {
+                ptr<Stmt> new_val;
+                ssize_t old_idx;
+                bool is_old;
+
+                delta(const Stmt * s, ssize_t i, bool old) :
+                        new_val(s), old_idx(i), is_old(old) {}
+        };
+
+        bool differs = false;
+        container_t< delta > values;
+
+        template< typename object_t, typename super_t, typename field_t >
+        void apply( object_t * object, field_t super_t::* field ) {
+                field_t & 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 ) );
                         }
                 }
 
-                ~guard_value() {
-                        while( !cleanups.empty() ) {
-                                auto& cleanup = cleanups.top();
-                                cleanup.func( cleanup.val );
-                                cleanups.pop();
-                        }
-                }
-
-                void push( cleanup_func_t && func, void* val ) {
-                        cleanups.emplace( std::move(func), val );
-                }
-
-        private:
-                struct cleanup_t {
-                        cleanup_func_t func;
-                        void * val;
-
-                        cleanup_t( cleanup_func_t&& func, void * val ) : func(func), val(val) {}
-                };
-
-                std::stack< cleanup_t, std::vector<cleanup_t> > cleanups;
-        };
-
-        // Guard structure implementation for whether or not children should be visited
-        class visit_children_guard {
-        public:
-
-                visit_children_guard( bool_ref * ref )
-                        : m_val ( true )
-                        , m_prev( ref ? ref->set( &m_val ) : nullptr )
-                        , m_ref ( ref )
-                {}
-
-                ~visit_children_guard() {
-                        if( m_ref ) {
-                                m_ref->set( m_prev );
-                        }
-                }
-
-                operator bool() { return m_val; }
-
-        private:
-                bool       m_val;
-                bool     * m_prev;
-                bool_ref * m_ref;
-        };
-
-        /// "Short hand" to check if this is a valid previsit function
-        /// Mostly used to make the static_assert look (and print) prettier
+                container = std::move(nvals);
+        }
+
+        template< template<class...> class incontainer_t >
+        void 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 incontainer_t >
+        void 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 {
+                                ast::Decl const * d = decl.release();
+                                return delta( new DeclStmt( d->location, d ), -1, false );
+                        });
+                decls->clear();
+                differs = true;
+        }
+};
+
+/// The result is a container of nodes.
+template< template<class...> class container_t, typename node_t >
+struct resultN {
+        bool differs = false;
+        container_t<ptr<node_t>> values;
+
+        template< typename object_t, typename super_t, typename field_t >
+        void apply( object_t * object, field_t super_t::* field ) {
+                field_t & 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.
+        }
+};
+
+/// Used by previsit implementation
+/// We need to reassign the result to 'node', unless the function
+/// returns void, then we just leave 'node' unchanged
+template<bool is_void>
+struct __assign;
+
+template<>
+struct __assign<true> {
         template<typename core_t, typename node_t>
-        struct is_valid_previsit {
-                using ret_t = decltype( std::declval<core_t*>()->previsit( std::declval<const node_t *>() ) );
-
-                static constexpr bool value = std::is_void< ret_t >::value ||
-                        std::is_base_of<const node_t, typename std::remove_pointer<ret_t>::type >::value;
-        };
-
-        /// The result is a single node.
-        template< typename node_t >
-        struct result1 {
-                bool differs = false;
-                const node_t * value = nullptr;
-
-                template< typename object_t, typename super_t, typename field_t >
-                void apply( object_t *, field_t super_t::* field );
-        };
-
-        /// The result is a container of statements.
-        template< template<class...> class container_t >
-        struct resultNstmt {
-                /// The delta/change on a single node.
-                struct delta {
-                        ptr<Stmt> new_val;
-                        ssize_t old_idx;
-                        bool is_old;
-
-                        delta(const Stmt * s, ssize_t i, bool old) :
-                                new_val(s), old_idx(i), is_old(old) {}
-                };
-
-                bool differs = false;
-                container_t< delta > values;
-
-                template< typename object_t, typename super_t, typename field_t >
-                void apply( object_t *, field_t super_t::* field );
-
-                template< template<class...> class incontainer_t >
-                void take_all( incontainer_t<ptr<Stmt>> * stmts );
-
-                template< template<class...> class incontainer_t >
-                void take_all( incontainer_t<ptr<Decl>> * decls );
-        };
-
-        /// The result is a container of nodes.
-        template< template<class...> class container_t, typename node_t >
-        struct resultN {
-                bool differs = false;
-                container_t<ptr<node_t>> values;
-
-                template< typename object_t, typename super_t, typename field_t >
-                void apply( object_t *, field_t super_t::* field );
-        };
-
-        /// Used by previsit implementation
-        /// We need to reassign the result to 'node', unless the function
-        /// returns void, then we just leave 'node' unchanged
-        template<bool is_void>
-        struct __assign;
-
-        template<>
-        struct __assign<true> {
-                template<typename core_t, typename node_t>
-                static inline void result( core_t & core, const node_t * & node ) {
-                        core.previsit( node );
-                }
-        };
-
-        template<>
-        struct __assign<false> {
-                template<typename core_t, typename node_t>
-                static inline void result( core_t & core, const node_t * & node ) {
-                        node = core.previsit( node );
-                        assertf(node, "Previsit must not return NULL");
-                }
-        };
-
-        /// Used by postvisit implementation
-        /// We need to return the result unless the function
-        /// returns void, then we just return the original node
-        template<bool is_void>
-        struct __return;
-
-        template<>
-        struct __return<true> {
-                template<typename core_t, typename node_t>
-                static inline const node_t * result( core_t & core, const node_t * & node ) {
-                        core.postvisit( node );
-                        return node;
-                }
-        };
-
-        template<>
-        struct __return<false> {
-                template<typename core_t, typename node_t>
-                static inline auto result( core_t & core, const node_t * & node ) {
-                        return core.postvisit( node );
-                }
-        };
-
-        //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-        // Deep magic (a.k.a template meta programming) to make the templated visitor work
-        // Basically the goal is to make 2 previsit
-        // 1 - Use when a pass implements a valid previsit. This uses overloading which means the any overload of
-        //     'pass.previsit( node )' that compiles will be used for that node for that type
-        //     This requires that this option only compile for passes that actually define an appropriate visit.
-        //     SFINAE will make sure the compilation errors in this function don't halt the build.
-        //     See http://en.cppreference.com/w/cpp/language/sfinae for details on SFINAE
-        // 2 - Since the first implementation might not be specilizable, the second implementation exists and does nothing.
-        //     This is needed only to eliminate the need for passes to specify any kind of handlers.
-        //     The second implementation only works because it has a lower priority. This is due to the bogus last parameter.
-        //     The second implementation takes a long while the first takes an int. Since the caller always passes an literal 0
-        //     the first implementation takes priority in regards to overloading.
-        //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-        // PreVisit : may mutate the pointer passed in if the node is mutated in the previsit call
+        static inline void result( core_t & core, const node_t * & node ) {
+                core.previsit( node );
+        }
+};
+
+template<>
+struct __assign<false> {
         template<typename core_t, typename node_t>
-        static inline auto previsit( core_t & core, const node_t * & node, int ) -> decltype( core.previsit( node ), void() ) {
-                static_assert(
-                        is_valid_previsit<core_t, node_t>::value,
-                        "Previsit may not change the type of the node. It must return its paremeter or void."
-                );
-
-                __assign<
-                        std::is_void<
-                                decltype( core.previsit( node ) )
-                        >::value
-                >::result( core, node );
-        }
-
+        static inline void result( core_t & core, const node_t * & node ) {
+                node = core.previsit( node );
+                assertf(node, "Previsit must not return NULL");
+        }
+};
+
+/// Used by postvisit implementation
+/// We need to return the result unless the function
+/// returns void, then we just return the original node
+template<bool is_void>
+struct __return;
+
+template<>
+struct __return<true> {
         template<typename core_t, typename node_t>
-        static inline auto previsit( core_t &, const node_t *, long ) {}
-
-        // PostVisit : never mutates the passed pointer but may return a different node
+        static inline const node_t * result( core_t & core, const node_t * & node ) {
+                core.postvisit( node );
+                return node;
+        }
+};
+
+template<>
+struct __return<false> {
         template<typename core_t, typename node_t>
-        static inline auto postvisit( core_t & core, const node_t * node, int ) ->
-                decltype( core.postvisit( node ), node->accept( *(Visitor*)nullptr ) )
-        {
-                return __return<
-                        std::is_void<
-                                decltype( core.postvisit( node ) )
-                        >::value
-                >::result( core, node );
-        }
-
-        template<typename core_t, typename node_t>
-        static inline const node_t * postvisit( core_t &, const node_t * node, long ) { return node; }
-
-        //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-        // Deep magic (a.k.a template meta programming) continued
-        // To make the templated visitor be more expressive, we allow 'accessories' : classes/structs the implementation can inherit
-        // from in order to get extra functionallity for example
-        // class ErrorChecker : WithShortCircuiting { ... };
-        // Pass<ErrorChecker> checker;
-        // this would define a pass that uses the templated visitor with the additionnal feature that it has short circuiting
-        // Note that in all cases the accessories are not required but guarantee the requirements of the feature is matched
-        //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-        // For several accessories, the feature is enabled by detecting that a specific field is present
-        // Use a macro the encapsulate the logic of detecting a particular field
-        // The type is not strictly enforced but does match the accessory
-        #define FIELD_PTR( name, default_type ) \
-        template< typename core_t > \
-        static inline auto name( core_t & core, int ) -> decltype( &core.name ) { return &core.name; } \
+        static inline auto result( core_t & core, const node_t * & node ) {
+                return core.postvisit( node );
+        }
+};
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// Deep magic (a.k.a template meta programming) to make the templated visitor work
+// Basically the goal is to make 2 previsit
+// 1 - Use when a pass implements a valid previsit. This uses overloading which means the any overload of
+//     'pass.previsit( node )' that compiles will be used for that node for that type
+//     This requires that this option only compile for passes that actually define an appropriate visit.
+//     SFINAE will make sure the compilation errors in this function don't halt the build.
+//     See http://en.cppreference.com/w/cpp/language/sfinae for details on SFINAE
+// 2 - Since the first implementation might not be specilizable, the second implementation exists and does nothing.
+//     This is needed only to eliminate the need for passes to specify any kind of handlers.
+//     The second implementation only works because it has a lower priority. This is due to the bogus last parameter.
+//     The second implementation takes a long while the first takes an int. Since the caller always passes an literal 0
+//     the first implementation takes priority in regards to overloading.
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// PreVisit : may mutate the pointer passed in if the node is mutated in the previsit call
+template<typename core_t, typename node_t>
+static inline auto previsit( core_t & core, const node_t * & node, int ) -> decltype( core.previsit( node ), void() ) {
+        static_assert(
+                is_valid_previsit<core_t, node_t>::value,
+                "Previsit may not change the type of the node. It must return its paremeter or void."
+        );
+
+        __assign<
+                std::is_void<
+                        decltype( core.previsit( node ) )
+                >::value
+        >::result( core, node );
+}
+
+template<typename core_t, typename node_t>
+static inline auto previsit( core_t &, const node_t *, long ) {}
+
+// PostVisit : never mutates the passed pointer but may return a different node
+template<typename core_t, typename node_t>
+static inline auto postvisit( core_t & core, const node_t * node, int ) ->
+        decltype( core.postvisit( node ), node->accept( *(Visitor*)nullptr ) )
+{
+        return __return<
+                std::is_void<
+                        decltype( core.postvisit( node ) )
+                >::value
+        >::result( core, node );
+}
+
+template<typename core_t, typename node_t>
+static inline const node_t * postvisit( core_t &, const node_t * node, long ) { return node; }
+
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// Deep magic (a.k.a template meta programming) continued
+// To make the templated visitor be more expressive, we allow 'accessories' : classes/structs the implementation can inherit
+// from in order to get extra functionallity for example
+// class ErrorChecker : WithShortCircuiting { ... };
+// Pass<ErrorChecker> checker;
+// this would define a pass that uses the templated visitor with the additionnal feature that it has short circuiting
+// Note that in all cases the accessories are not required but guarantee the requirements of the feature is matched
+//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+// For several accessories, the feature is enabled by detecting that a specific field is present
+// Use a macro the encapsulate the logic of detecting a particular field
+// The type is not strictly enforced but does match the accessory
+#define FIELD_PTR( name, default_type ) \
+template< typename core_t > \
+static inline auto name( core_t & core, int ) -> decltype( &core.name ) { return &core.name; } \
+\
+template< typename core_t > \
+static inline default_type * name( core_t &, long ) { return nullptr; }
+
+// List of fields and their expected types
+FIELD_PTR( typeSubs, const ast::TypeSubstitution * )
+FIELD_PTR( stmtsToAddBefore, std::list< ast::ptr< ast::Stmt > > )
+FIELD_PTR( stmtsToAddAfter , std::list< ast::ptr< ast::Stmt > > )
+FIELD_PTR( declsToAddBefore, std::list< ast::ptr< ast::Decl > > )
+FIELD_PTR( declsToAddAfter , std::list< ast::ptr< ast::Decl > > )
+FIELD_PTR( visit_children, __pass::bool_ref )
+FIELD_PTR( at_cleanup, __pass::at_cleanup_t )
+FIELD_PTR( visitor, ast::Pass<core_t> * const )
+
+// Remove the macro to make sure we don't clash
+#undef FIELD_PTR
+
+template< typename core_t >
+static inline auto beginTrace(core_t &, int) -> decltype( core_t::traceId, void() ) {
+        // Stats::Heap::stacktrace_push(core_t::traceId);
+}
+
+template< typename core_t >
+static inline auto endTrace(core_t &, int) -> decltype( core_t::traceId, void() ) {
+        // Stats::Heap::stacktrace_pop();
+}
+
+template< typename core_t >
+static void beginTrace(core_t &, long) {}
+
+template< typename core_t >
+static void endTrace(core_t &, long) {}
+
+// Allows visitor to handle an error on top-level declarations, and possibly suppress the error.
+// If on_error() returns false, the error will be ignored. By default, it returns true.
+
+template< typename core_t >
+static bool on_error (core_t &, ptr<Decl> &, long) { return true; }
+
+template< typename core_t >
+static auto on_error (core_t & core, ptr<Decl> & decl, int) -> decltype(core.on_error(decl)) {
+        return core.on_error(decl);
+}
+
+template< typename core_t, typename node_t >
+static auto make_location_guard( core_t & core, node_t * node, int )
+                -> decltype( node->location, ValueGuardPtr<const CodeLocation *>( &core.location ) ) {
+        ValueGuardPtr<const CodeLocation *> guard( &core.location );
+        core.location = &node->location;
+        return guard;
+}
+
+template< typename core_t, typename node_t >
+static auto make_location_guard( core_t &, node_t *, long ) -> int {
+        return 0;
+}
+
+// Another feature of the templated visitor is that it calls beginScope()/endScope() for compound statement.
+// All passes which have such functions are assumed desire this behaviour
+// detect it using the same strategy
+namespace scope {
+        template<typename core_t>
+        static inline auto enter( core_t & core, int ) -> decltype( core.beginScope(), void() ) {
+                core.beginScope();
+        }
+
+        template<typename core_t>
+        static inline void enter( core_t &, long ) {}
+
+        template<typename core_t>
+        static inline auto leave( core_t & core, int ) -> decltype( core.endScope(), void() ) {
+                core.endScope();
+        }
+
+        template<typename core_t>
+        static inline void leave( core_t &, long ) {}
+} // namespace scope
+
+// Certain passes desire an up to date symbol table automatically
+// detect the presence of a member name `symtab` and call all the members appropriately
+namespace symtab {
+        // Some simple scoping rules
+        template<typename core_t>
+        static inline auto enter( core_t & core, int ) -> decltype( core.symtab, void() ) {
+                core.symtab.enterScope();
+        }
+
+        template<typename core_t>
+        static inline auto enter( core_t &, long ) {}
+
+        template<typename core_t>
+        static inline auto leave( core_t & core, int ) -> decltype( core.symtab, void() ) {
+                core.symtab.leaveScope();
+        }
+
+        template<typename core_t>
+        static inline auto leave( core_t &, long ) {}
+
+        // The symbol table has 2 kind of functions mostly, 1 argument and 2 arguments
+        // Create macro to condense these common patterns
+        #define SYMTAB_FUNC1( func, type ) \
+        template<typename core_t> \
+        static inline auto func( core_t & core, int, type arg ) -> decltype( core.symtab.func( arg ), void() ) {\
+                core.symtab.func( arg ); \
+        } \
         \
-        template< typename core_t > \
-        static inline default_type * name( core_t &, long ) { return nullptr; }
-
-        // List of fields and their expected types
-        FIELD_PTR( typeSubs, const ast::TypeSubstitution * )
-        FIELD_PTR( stmtsToAddBefore, std::list< ast::ptr< ast::Stmt > > )
-        FIELD_PTR( stmtsToAddAfter , std::list< ast::ptr< ast::Stmt > > )
-        FIELD_PTR( declsToAddBefore, std::list< ast::ptr< ast::Decl > > )
-        FIELD_PTR( declsToAddAfter , std::list< ast::ptr< ast::Decl > > )
-        FIELD_PTR( visit_children, __pass::bool_ref )
-        FIELD_PTR( at_cleanup, __pass::at_cleanup_t )
-        FIELD_PTR( visitor, ast::Pass<core_t> * const )
-
-        // Remove the macro to make sure we don't clash
-        #undef FIELD_PTR
-
-        template< typename core_t >
-        static inline auto beginTrace(core_t &, int) -> decltype( core_t::traceId, void() ) {
-                // Stats::Heap::stacktrace_push(core_t::traceId);
-        }
-
-        template< typename core_t >
-        static inline auto endTrace(core_t &, int) -> decltype( core_t::traceId, void() ) {
-                // Stats::Heap::stacktrace_pop();
-        }
-
-        template< typename core_t >
-        static void beginTrace(core_t &, long) {}
-
-        template< typename core_t >
-        static void endTrace(core_t &, long) {}
-
-        // Allows visitor to handle an error on top-level declarations, and possibly suppress the error.
-        // If onError() returns false, the error will be ignored. By default, it returns true.
-
-        template< typename core_t >
-        static bool on_error (core_t &, ptr<Decl> &, long) { return true; }
-
-        template< typename core_t >
-        static auto on_error (core_t & core, ptr<Decl> & decl, int) -> decltype(core.on_error(decl)) {
-                return core.on_error(decl);
-        }
-
-        template< typename core_t, typename node_t >
-        static auto make_location_guard( core_t & core, node_t * node, int )
-                        -> decltype( node->location, ValueGuardPtr<const CodeLocation *>( &core.location ) ) {
-                ValueGuardPtr<const CodeLocation *> guard( &core.location );
-                core.location = &node->location;
-                return guard;
-        }
-
-        template< typename core_t, typename node_t >
-        static auto make_location_guard( core_t &, node_t *, long ) -> int {
-                return 0;
-        }
-
-        // Another feature of the templated visitor is that it calls beginScope()/endScope() for compound statement.
-        // All passes which have such functions are assumed desire this behaviour
-        // detect it using the same strategy
-        namespace scope {
-                template<typename core_t>
-                static inline auto enter( core_t & core, int ) -> decltype( core.beginScope(), void() ) {
-                        core.beginScope();
-                }
-
-                template<typename core_t>
-                static inline void enter( core_t &, long ) {}
-
-                template<typename core_t>
-                static inline auto leave( core_t & core, int ) -> decltype( core.endScope(), void() ) {
-                        core.endScope();
-                }
-
-                template<typename core_t>
-                static inline void leave( core_t &, long ) {}
-        } // namespace scope
-
-        // Certain passes desire an up to date symbol table automatically
-        // detect the presence of a member name `symtab` and call all the members appropriately
-        namespace symtab {
-                // Some simple scoping rules
-                template<typename core_t>
-                static inline auto enter( core_t & core, int ) -> decltype( core.symtab, void() ) {
-                        core.symtab.enterScope();
-                }
-
-                template<typename core_t>
-                static inline auto enter( core_t &, long ) {}
-
-                template<typename core_t>
-                static inline auto leave( core_t & core, int ) -> decltype( core.symtab, void() ) {
-                        core.symtab.leaveScope();
-                }
-
-                template<typename core_t>
-                static inline auto leave( core_t &, long ) {}
-
-                // The symbol table has 2 kind of functions mostly, 1 argument and 2 arguments
-                // Create macro to condense these common patterns
-                #define SYMTAB_FUNC1( func, type ) \
-                template<typename core_t> \
-                static inline auto func( core_t & core, int, type arg ) -> decltype( core.symtab.func( arg ), void() ) {\
-                        core.symtab.func( arg ); \
-                } \
-                \
-                template<typename core_t> \
-                static inline void func( core_t &, long, type ) {}
-
-                #define SYMTAB_FUNC2( func, type1, type2 ) \
-                template<typename core_t> \
-                static inline auto func( core_t & core, int, type1 arg1, type2 arg2 ) -> decltype( core.symtab.func( arg1, arg2 ), void () ) {\
-                        core.symtab.func( arg1, arg2 ); \
-                } \
-                        \
-                template<typename core_t> \
-                static inline void func( core_t &, long, type1, type2 ) {}
-
-                SYMTAB_FUNC1( addId     , const DeclWithType *  );
-                SYMTAB_FUNC1( addType   , const NamedTypeDecl * );
-                SYMTAB_FUNC1( addStruct , const StructDecl *    );
-                SYMTAB_FUNC1( addEnum   , const EnumDecl *      );
-                SYMTAB_FUNC1( addUnion  , const UnionDecl *     );
-                SYMTAB_FUNC1( addTrait  , const TraitDecl *     );
-                SYMTAB_FUNC2( addWith   , const std::vector< ptr<Expr> > &, const Decl * );
-
-                // A few extra functions have more complicated behaviour, they are hand written
-                template<typename core_t>
-                static inline auto addStructFwd( core_t & core, int, const ast::StructDecl * decl ) -> decltype( core.symtab.addStruct( decl ), void() ) {
-                        ast::StructDecl * fwd = new ast::StructDecl( decl->location, decl->name );
-                        for ( const auto & param : decl->params ) {
-                                fwd->params.push_back( deepCopy( param.get() ) );
-                        }
-                        core.symtab.addStruct( fwd );
-                }
-
-                template<typename core_t>
-                static inline void addStructFwd( core_t &, long, const ast::StructDecl * ) {}
-
-                template<typename core_t>
-                static inline auto addUnionFwd( core_t & core, int, const ast::UnionDecl * decl ) -> decltype( core.symtab.addUnion( decl ), void() ) {
-                        ast::UnionDecl * fwd = new ast::UnionDecl( decl->location, decl->name );
-                        for ( const auto & param : decl->params ) {
-                                fwd->params.push_back( deepCopy( param.get() ) );
-                        }
-                        core.symtab.addUnion( fwd );
-                }
-
-                template<typename core_t>
-                static inline void addUnionFwd( core_t &, long, const ast::UnionDecl * ) {}
-
-                template<typename core_t>
-                static inline auto addStruct( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addStruct( str ), void() ) {
-                        if ( ! core.symtab.lookupStruct( str ) ) {
-                                core.symtab.addStruct( str );
-                        }
-                }
-
-                template<typename core_t>
-                static inline void addStruct( core_t &, long, const std::string & ) {}
-
-                template<typename core_t>
-                static inline auto addUnion( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addUnion( str ), void() ) {
-                        if ( ! core.symtab.lookupUnion( str ) ) {
-                                core.symtab.addUnion( str );
-                        }
-                }
-
-                template<typename core_t>
-                static inline void addUnion( core_t &, long, const std::string & ) {}
-
-                #undef SYMTAB_FUNC1
-                #undef SYMTAB_FUNC2
-        } // namespace symtab
-
-        // Some passes need to mutate TypeDecl and properly update their pointing TypeInstType.
-        // Detect the presence of a member name `subs` and call all members appropriately
-        namespace forall {
-                // Some simple scoping rules
-                template<typename core_t>
-                static inline auto enter( core_t & core, int, const ast::FunctionType * type )
-                -> decltype( core.subs, void() ) {
-                        if ( ! type->forall.empty() ) core.subs.beginScope();
-                }
-
-                template<typename core_t>
-                static inline auto enter( core_t &, long, const ast::FunctionType * ) {}
-
-                template<typename core_t>
-                static inline auto leave( core_t & core, int, const ast::FunctionType * type )
-                -> decltype( core.subs, void() ) {
-                        if ( ! type->forall.empty() ) { core.subs.endScope(); }
-                }
-
-                template<typename core_t>
-                static inline auto leave( core_t &, long, const ast::FunctionType * ) {}
-
-                // Replaces a TypeInstType's base TypeDecl according to the table
-                template<typename core_t>
-                static inline auto replace( core_t & core, int, const ast::TypeInstType *& inst )
-                -> decltype( core.subs, void() ) {
-                        inst = ast::mutate_field(
-                                inst, &ast::TypeInstType::base, core.subs.replace( inst->base ) );
-                }
-
-                template<typename core_t>
-                static inline auto replace( core_t &, long, const ast::TypeInstType *& ) {}
-
-        } // namespace forall
-
-        // For passes that need access to the global context. Sreaches `translationUnit`
-        namespace translation_unit {
-                template<typename core_t>
-                static inline auto get_cptr( core_t & core, int )
-                                -> decltype( &core.translationUnit ) {
-                        return &core.translationUnit;
-                }
-
-                template<typename core_t>
-                static inline const TranslationUnit ** get_cptr( core_t &, long ) {
-                        return nullptr;
-                }
-        }
-
-        template<typename core_t>
-        static inline auto get_result( core_t & core, char ) -> decltype( core.result() ) {
+        template<typename core_t> \
+        static inline void func( core_t &, long, type ) {}
+
+        #define SYMTAB_FUNC2( func, type1, type2 ) \
+        template<typename core_t> \
+        static inline auto func( core_t & core, int, type1 arg1, type2 arg2 ) -> decltype( core.symtab.func( arg1, arg2 ), void () ) {\
+                core.symtab.func( arg1, arg2 ); \
+        } \
+        \
+        template<typename core_t> \
+        static inline void func( core_t &, long, type1, type2 ) {}
+
+        SYMTAB_FUNC1( addId     , const DeclWithType *  );
+        SYMTAB_FUNC1( addType   , const NamedTypeDecl * );
+        SYMTAB_FUNC1( addStruct , const StructDecl *    );
+        SYMTAB_FUNC1( addEnum   , const EnumDecl *      );
+        SYMTAB_FUNC1( addUnion  , const UnionDecl *     );
+        SYMTAB_FUNC1( addTrait  , const TraitDecl *     );
+        SYMTAB_FUNC2( addWith   , const std::vector< ptr<Expr> > &, const Decl * );
+
+        // A few extra functions have more complicated behaviour, they are hand written
+        template<typename core_t>
+        static inline auto addStructFwd( core_t & core, int, const ast::StructDecl * decl ) -> decltype( core.symtab.addStruct( decl ), void() ) {
+                ast::StructDecl * fwd = new ast::StructDecl( decl->location, decl->name );
+                for ( const auto & param : decl->params ) {
+                        fwd->params.push_back( deepCopy( param.get() ) );
+                }
+                core.symtab.addStruct( fwd );
+        }
+
+        template<typename core_t>
+        static inline void addStructFwd( core_t &, long, const ast::StructDecl * ) {}
+
+        template<typename core_t>
+        static inline auto addUnionFwd( core_t & core, int, const ast::UnionDecl * decl ) -> decltype( core.symtab.addUnion( decl ), void() ) {
+                ast::UnionDecl * fwd = new ast::UnionDecl( decl->location, decl->name );
+                for ( const auto & param : decl->params ) {
+                        fwd->params.push_back( deepCopy( param.get() ) );
+                }
+                core.symtab.addUnion( fwd );
+        }
+
+        template<typename core_t>
+        static inline void addUnionFwd( core_t &, long, const ast::UnionDecl * ) {}
+
+        template<typename core_t>
+        static inline auto addStruct( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addStruct( str ), void() ) {
+                if ( ! core.symtab.lookupStruct( str ) ) {
+                        core.symtab.addStruct( str );
+                }
+        }
+
+        template<typename core_t>
+        static inline void addStruct( core_t &, long, const std::string & ) {}
+
+        template<typename core_t>
+        static inline auto addUnion( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addUnion( str ), void() ) {
+                if ( ! core.symtab.lookupUnion( str ) ) {
+                        core.symtab.addUnion( str );
+                }
+        }
+
+        template<typename core_t>
+        static inline void addUnion( core_t &, long, const std::string & ) {}
+
+        #undef SYMTAB_FUNC1
+        #undef SYMTAB_FUNC2
+} // namespace symtab
+
+// Some passes need to mutate TypeDecl and properly update their pointing TypeInstType.
+// Detect the presence of a member name `subs` and call all members appropriately
+namespace forall {
+        // Some simple scoping rules
+        template<typename core_t>
+        static inline auto enter( core_t & core, int, const ast::FunctionType * type )
+                        -> decltype( core.subs, void() ) {
+                if ( ! type->forall.empty() ) core.subs.beginScope();
+        }
+
+        template<typename core_t>
+        static inline auto enter( core_t &, long, const ast::FunctionType * ) {}
+
+        template<typename core_t>
+        static inline auto leave( core_t & core, int, const ast::FunctionType * type )
+                        -> decltype( core.subs, void() ) {
+                if ( ! type->forall.empty() ) { core.subs.endScope(); }
+        }
+
+        template<typename core_t>
+        static inline auto leave( core_t &, long, const ast::FunctionType * ) {}
+
+        // Replaces a TypeInstType's base TypeDecl according to the table
+        template<typename core_t>
+        static inline auto replace( core_t & core, int, const ast::TypeInstType *& inst )
+                        -> decltype( core.subs, void() ) {
+                inst = ast::mutate_field(
+                        inst, &ast::TypeInstType::base, core.subs.replace( inst->base ) );
+        }
+
+        template<typename core_t>
+        static inline auto replace( core_t &, long, const ast::TypeInstType *& ) {}
+} // namespace forall
+
+// For passes that need access to the global context. Searches `translationUnit`
+namespace translation_unit {
+        template<typename core_t>
+        static inline auto get_cptr( core_t & core, int )
+                        -> decltype( &core.translationUnit ) {
+                return &core.translationUnit;
+        }
+
+        template<typename core_t>
+        static inline const TranslationUnit ** get_cptr( core_t &, long ) {
+                return nullptr;
+        }
+}
+
+// For passes, usually utility passes, that have a result.
+namespace result {
+        template<typename core_t>
+        static inline auto get( core_t & core, char ) -> decltype( core.result() ) {
                 return core.result();
         }
 
         template<typename core_t>
-        static inline auto get_result( core_t & core, int ) -> decltype( core.result ) {
+        static inline auto get( core_t & core, int ) -> decltype( core.result ) {
                 return core.result;
         }
 
         template<typename core_t>
-        static inline void get_result( core_t &, long ) {}
-} // namespace __pass
-} // namespace ast
+        static inline void get( core_t &, long ) {}
+}
+
+} // namespace ast::__pass
+
+#undef __pedantic_pass_assertf
+#undef __pedantic_pass_assert

src/AST/Print.cpp

@@ -16 +16 @@
 #include "Print.hpp"
 
+#include "Attribute.hpp"
 #include "Decl.hpp"
 #include "Expr.hpp"
+#include "Init.hpp"
 #include "Stmt.hpp"
 #include "Type.hpp"
 #include "TypeSubstitution.hpp"
 #include "CompilationState.h"
-
-#include "Common/utility.h" // for group_iterate
+#include "Common/Iterate.hpp"
 
 using namespace std;
@@ -29 +30 @@
 namespace ast {
 
-template <typename C, typename... T>
-constexpr array<C,sizeof...(T)> make_array(T&&... values)
-{
-        return array<C,sizeof...(T)>{
-                std::forward<T>(values)...
-        };
+namespace {
+
+template<typename C, typename... T>
+constexpr array<C, sizeof...(T)> make_array( T&&... values ) {
+        return array<C, sizeof...(T)>{ std::forward<T>( values )... };
+}
+
+namespace Names {
+        static constexpr auto FuncSpecifiers = make_array<const char*>(
+                "inline", "_Noreturn", "fortran"
+        );
+
+        static constexpr auto StorageClasses = make_array<const char*>(
+                "extern", "static", "auto", "register", "__thread", "_Thread_local"
+        );
+
+        static constexpr auto Qualifiers = make_array<const char*>(
+                "const", "restrict", "volatile", "mutex", "_Atomic"
+        );
+}
+
+template<typename bits_t, size_t N>
+void print( ostream & os, const bits_t & bits,
+                const array<const char *, N> & names ) {
+        if ( !bits.any() ) return;
+        for ( size_t i = 0 ; i < N ; i += 1 ) {
+                if ( bits[i] ) {
+                        os << names[i] << ' ';
+                }
+        }
 }
 
@@ -80 +105 @@
         static const char* Names[];
 
-        struct Names {
-                static constexpr auto FuncSpecifiers = make_array<const char*>(
-                        "inline", "_Noreturn", "fortran"
-                );
-
-                static constexpr auto StorageClasses = make_array<const char*>(
-                        "extern", "static", "auto", "register", "__thread", "_Thread_local"
-                );
-
-                static constexpr auto Qualifiers = make_array<const char*>(
-                        "const", "restrict", "volatile", "mutex", "_Atomic"
-                );
-        };
-
-        template<typename storage_t, size_t N>
-        void print(const storage_t & storage, const array<const char *, N> & Names ) {
-                if ( storage.any() ) {
-                        for ( size_t i = 0; i < Names.size(); i += 1 ) {
-                                if ( storage[i] ) {
-                                        os << Names[i] << ' ';
-                                }
-                        }
-                }
-        }
-
-        void print( const ast::Function::Specs & specs ) {
-                print(specs, Names::FuncSpecifiers);
-        }
-
-        void print( const ast::Storage::Classes & storage ) {
-                print(storage, Names::StorageClasses);
-        }
-
-        void print( const ast::CV::Qualifiers & qualifiers ) {
-                print(qualifiers, Names::Qualifiers);
-        }
-
         void print( const std::vector<ast::Label> & labels ) {
                 if ( labels.empty() ) return;
@@ -221 +209 @@
         }
 
+    void print( const ast::WaitStmt * node ) {
+                if ( node->timeout_time ) {
+                        os << indent-1 << "timeout of:" << endl;
+                        node->timeout_time->accept( *this );
+
+                        if ( node->timeout_stmt ) {
+                                os << indent-1 << "... with statment:" << endl;
+                                node->timeout_stmt->accept( *this );
+                        }
+
+                        if ( node->timeout_cond ) {
+                                os << indent-1 << "... with condition:" << endl;
+                                node->timeout_cond->accept( *this );
+                        }
+                }
+
+                if ( node->else_stmt ) {
+                        os << indent-1 << "else:" << endl;
+                        node->else_stmt->accept( *this );
+
+                        if ( node->else_cond ) {
+                                os << indent-1 << "... with condition:" << endl;
+                                node->else_cond->accept( *this );
+                        }
+                }
+        }
+
         void preprint( const ast::NamedTypeDecl * node ) {
                 if ( ! node->name.empty() ) {
@@ -230 +245 @@
                 }
 
-                print( node->storage );
+                ast::print( os, node->storage );
                 os << node->typeString();
 
@@ -272 +287 @@
 
         void preprint( const ast::Type * node ) {
-                print( node->qualifiers );
+                ast::print( os, node->qualifiers );
         }
 
@@ -278 +293 @@
                 print( node->forall );
                 print( node->assertions );
-                print( node->qualifiers );
+                ast::print( os, node->qualifiers );
         }
 
         void preprint( const ast::BaseInstType * node ) {
                 print( node->attributes );
-                print( node->qualifiers );
+                ast::print( os, node->qualifiers );
         }
 
@@ -294 +309 @@
                 }
 
-                print( node->storage );
+                ast::print( os, node->storage );
 
                 if ( node->type ) {
@@ -338 +353 @@
                 if ( ! short_mode ) printAll( node->attributes );
 
-                print( node->storage );
-                print( node->funcSpec );
-
-
+                ast::print( os, node->storage );
+                ast::print( os, node->funcSpec );
 
                 if ( node->type && node->isTypeFixed ) {
@@ -384 +397 @@
                                 --indent;
                         }
+                }
+
+                if ( ! node->withExprs.empty() ) {
+                        // Not with a clause, but the 'with clause'.
+                        ++indent;
+                        os << " with clause" << endl << indent;
+                        printAll( node->withExprs );
+                        --indent;
                 }
 
@@ -746 +767 @@
         virtual const ast::Stmt * visit( const ast::SuspendStmt * node ) override final {
                 os << "Suspend Statement";
-                switch (node->type) {
-                        case ast::SuspendStmt::None     : os << " with implicit target"; break;
-                        case ast::SuspendStmt::Generator: os << " for generator"; break;
-                        case ast::SuspendStmt::Coroutine: os << " for coroutine"; break;
+                switch (node->kind) {
+                case ast::SuspendStmt::None     : os << " with implicit target"; break;
+                case ast::SuspendStmt::Generator: os << " for generator"; break;
+                case ast::SuspendStmt::Coroutine: os << " for coroutine"; break;
                 }
                 os << endl;
@@ -759 +780 @@
                 }
                 ++indent;
+
+                return node;
+        }
+
+        virtual const ast::WhenClause * visit( const ast::WhenClause * node ) override final {
+                os << indent-1 << "target: ";
+                safe_print( node->target );
+
+                if ( node->stmt ) {
+                        os << indent-1 << "... with statment:" << endl;
+                        node->stmt->accept( *this );
+                }
+
+                if ( node->when_cond ) {
+                        os << indent-1 << "... with when condition:" << endl;
+                        node->when_cond->accept( *this );
+                }
 
                 return node;
@@ -800 +838 @@
         virtual const ast::WaitForClause * visit( const ast::WaitForClause * node ) override final {
                 os << indent-1 << "target function: ";
-                safe_print( node->target_func );
+                safe_print( node->target );
 
                 if ( !node->target_args.empty() ) {
@@ -814 +852 @@
                 }
 
-                if ( node->cond ) {
+                if ( node->when_cond ) {
                         os << indent-1 << "... with condition:" << endl;
-                        node->cond->accept( *this );
-                }
-
+                        node->when_cond->accept( *this );
+                }
+
+                return node;
+        }
+
+    virtual const ast::Stmt * visit( const ast::WaitUntilStmt * node ) override final {
+                os << "Waituntil Statement" << endl;
+                indent += 2;
+                for( const auto & clause : node->clauses ) {
+                        clause->accept( *this );
+                }
+        print(node);    // calls print( const ast::WaitStmt * node )
                 return node;
         }
@@ -1627 +1675 @@
 };
 
+} // namespace
+
 void print( ostream & os, const ast::Node * node, Indenter indent ) {
         Printer printer { os, indent, false };
@@ -1637 +1687 @@
 }
 
-// Annoyingly these needed to be defined out of line to avoid undefined references.
-// The size here needs to be explicit but at least the compiler will produce an error
-// if the wrong size is specified
-constexpr array<const char*, 3> Printer::Names::FuncSpecifiers;
-constexpr array<const char*, 6> Printer::Names::StorageClasses;
-constexpr array<const char*, 5> Printer::Names::Qualifiers;
+void print( ostream & os, Function::Specs specs ) {
+        print( os, specs, Names::FuncSpecifiers );
 }
+
+void print( ostream & os, Storage::Classes storage ) {
+        print( os, storage, Names::StorageClasses );
+}
+
+void print( ostream & os, CV::Qualifiers qualifiers ) {
+        print( os, qualifiers, Names::Qualifiers );
+}
+
+} // namespace ast

src/AST/Print.hpp

@@ -16 +16 @@
 #pragma once
 
-#include <iostream>
-#include <utility>   // for forward
+#include <iosfwd>
 
-#include "AST/Node.hpp"
+#include "AST/Fwd.hpp"
 #include "Common/Indenter.h"
 
 namespace ast {
-
-class Decl;
 
 /// Print a node with the given indenter
@@ -44 +41 @@
 }
 
+/// Print each cv-qualifier used in the set, followed by a space.
+void print( std::ostream & os, CV::Qualifiers );
+/// Print each function specifier used in the set, followed by a space.
+void print( std::ostream & os, Function::Specs );
+/// Print each storage class used in the set, followed by a space.
+void print( std::ostream & os, Storage::Classes );
+
 }

src/AST/Stmt.hpp

@@ -10 +10 @@
 // Created On       : Wed May  8 13:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Apr 20 14:34:00 2022
-// Update Count     : 36
+// Last Modified On : Wed Apr  5 10:34:00 2023
+// Update Count     : 37
 //
 
@@ -205 +205 @@
 };
 
+// A while loop or a do-while loop:
+enum WhileDoKind { While, DoWhile };
+
 // While loop: while (...) ... else ... or do ... while (...) else ...;
 class WhileDoStmt final : public Stmt {
@@ -212 +215 @@
         ptr<Stmt> else_;
         std::vector<ptr<Stmt>> inits;
-        bool isDoWhile;
+        WhileDoKind isDoWhile;
 
         WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
-                                 const std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, const std::vector<Label> && labels = {} )
+                                 const std::vector<ptr<Stmt>> && inits, WhileDoKind isDoWhile = While, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(nullptr), inits(std::move(inits)), isDoWhile(isDoWhile) {}
 
         WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body, const Stmt * else_,
-                                 const std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, const std::vector<Label> && labels = {} )
+                                 const std::vector<ptr<Stmt>> && inits, WhileDoKind isDoWhile = While, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(else_), inits(std::move(inits)), isDoWhile(isDoWhile) {}
 
@@ -364 +367 @@
   public:
         ptr<CompoundStmt> then;
-        enum Type { None, Coroutine, Generator } type = None;
-
-        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, const std::vector<Label> && labels = {} )
-                : Stmt(loc, std::move(labels)), then(then), type(type) {}
+        enum Kind { None, Coroutine, Generator } kind = None;
+
+        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Kind kind, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), then(then), kind(kind) {}
 
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -375 +378 @@
 };
 
-// Waitfor statement: when (...) waitfor (... , ...) ... timeout(...) ... else ...
-class WaitForStmt final : public Stmt {
-  public:
-        std::vector<ptr<WaitForClause>> clauses;
-        ptr<Expr> timeout_time;
+// Base class of WaitFor/WaitUntil statements
+// form: KEYWORD(...) ... timeout(...) ... else ...
+class WaitStmt : public Stmt { 
+  public:
+    ptr<Expr> timeout_time;
         ptr<Stmt> timeout_stmt;
         ptr<Expr> timeout_cond;
@@ -385 +388 @@
         ptr<Expr> else_cond;
 
+    WaitStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)) {}
+
+  private:
+    WaitStmt * clone() const override = 0;
+        MUTATE_FRIEND
+};
+
+// Base class for WaitFor/WaitUntil clauses
+// form: when( when_cond ) KEYWORD( target ) stmt
+class WhenClause : public StmtClause {
+  public:
+        ptr<Expr> target;
+        ptr<Stmt> stmt;
+        ptr<Expr> when_cond;
+
+        WhenClause( const CodeLocation & loc )
+                : StmtClause( loc ) {}
+
+        const WhenClause * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+        WhenClause * clone() const override { return new WhenClause{ *this }; }
+        MUTATE_FRIEND
+};
+
+// Waitfor statement: when (...) waitfor (... , ...) ... timeout(...) ... else ...
+class WaitForStmt final : public WaitStmt {
+  public:
+        std::vector<ptr<WaitForClause>> clauses;
+
         WaitForStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
-                : Stmt(loc, std::move(labels)) {}
+                : WaitStmt(loc, std::move(labels)) {}
 
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -394 +427 @@
 };
 
-class WaitForClause final : public StmtClause {
-  public:
-        ptr<Expr> target_func;
+// Clause in a waitfor statement: waitfor (..., ...) ...
+class WaitForClause final : public WhenClause {
+  public:
         std::vector<ptr<Expr>> target_args;
-        ptr<Stmt> stmt;
-        ptr<Expr> cond;
 
         WaitForClause( const CodeLocation & loc )
-                : StmtClause( loc ) {}
+                : WhenClause( loc ) {}
 
         const WaitForClause * accept( Visitor & v ) const override { return v.visit( this ); }
   private:
         WaitForClause * clone() const override { return new WaitForClause{ *this }; }
+        MUTATE_FRIEND
+};
+
+// waituntil statement: when (...) waituntil (...) ... timeout(...) ... else ...
+class WaitUntilStmt final : public WaitStmt {
+  public:
+    // Non-ast node used during compilation to store data needed to generate predicates
+    //    and set initial status values for clauses
+    // Used to create a tree corresponding to the structure of the clauses in a WaitUntil
+    struct ClauseNode { 
+        enum Op { AND, OR, LEFT_OR, LEAF, ELSE, TIMEOUT } op; // operation/type tag
+        // LEFT_OR used with TIMEOUT/ELSE to indicate that we ignore right hand side after parsing
+
+        ClauseNode * left;
+        ClauseNode * right;
+        WhenClause * leaf;  // only set if this node is a leaf (points into vector of clauses)
+
+        bool ambiguousWhen; // used to paint nodes of predicate tree based on when() clauses
+        bool whenState;     // used to track if when_cond is toggled on or off for generating init values
+        bool childOfAnd;      // true on leaf nodes that are children of AND, false otherwise
+
+        ClauseNode( Op op, ClauseNode * left, ClauseNode * right )
+            : op(op), left(left), right(right), leaf(nullptr), 
+            ambiguousWhen(false), whenState(true), childOfAnd(false) {}
+        ClauseNode( Op op, WhenClause * leaf )
+            : op(op), left(nullptr), right(nullptr), leaf(leaf),
+            ambiguousWhen(false), whenState(true), childOfAnd(false) {}
+        ClauseNode( WhenClause * leaf ) : ClauseNode(LEAF, leaf) {}
+        
+        ~ClauseNode() {
+            if ( left ) delete left;
+            if ( right ) delete right;
+        }
+    };
+
+        std::vector<ptr<WhenClause>> clauses;
+    ClauseNode * predicateTree;
+
+        WaitUntilStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
+                : WaitStmt(loc, std::move(labels)) {}
+
+    ~WaitUntilStmt() { delete predicateTree; }
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+        WaitUntilStmt * clone() const override { return new WaitUntilStmt{ *this }; }
         MUTATE_FRIEND
 };
@@ -454 +531 @@
         MUTATE_FRIEND
 };
+
 } // namespace ast
 

src/AST/SymbolTable.cpp

@@ -18 +18 @@
 #include <cassert>
 
+#include "Copy.hpp"
+#include <iostream>
+#include <algorithm>
+
 #include "Decl.hpp"
 #include "Expr.hpp"
 #include "Inspect.hpp"
 #include "Type.hpp"
-#include "CodeGen/OperatorTable.h"  // for isCtorDtorAssign
+#include "CodeGen/OperatorTable.h"         // for isCtorDtorAssign
 #include "Common/SemanticError.h"
 #include "Common/Stats/Counter.h"
@@ -28 +32 @@
 #include "InitTweak/InitTweak.h"
 #include "ResolvExpr/Cost.h"
-#include "ResolvExpr/typeops.h"
+#include "ResolvExpr/CandidateFinder.hpp"  // for referenceToRvalueConversion
+#include "ResolvExpr/Unify.h"
 #include "SymTab/Mangler.h"
 
@@ -69 +74 @@
         if ( baseExpr ) {
                 if (baseExpr->env) {
-                        Expr * base = shallowCopy(baseExpr);
+                        Expr * base = deepCopy(baseExpr);
                         const TypeSubstitution * subs = baseExpr->env;
                         base->env = nullptr;
@@ -193 +198 @@
                         out.push_back(decl.second);
                 }
+
+                // std::cerr << otypeKey << ' ' << out.size() << std::endl;
         }
 
@@ -259 +266 @@
 void SymbolTable::addId( const DeclWithType * decl, const Expr * baseExpr ) {
         // default handling of conflicts is to raise an error
-        addId( decl, OnConflict::error(), baseExpr, decl->isDeleted ? decl : nullptr );
+        addIdCommon( decl, OnConflict::error(), baseExpr, decl->isDeleted ? decl : nullptr );
 }
 
 void SymbolTable::addDeletedId( const DeclWithType * decl, const Decl * deleter ) {
         // default handling of conflicts is to raise an error
-        addId( decl, OnConflict::error(), nullptr, deleter );
+        addIdCommon( decl, OnConflict::error(), nullptr, deleter );
 }
 
@@ -276 +283 @@
                 } else {
                         // typedef redeclarations are errors only if types are different
-                        if ( ! ResolvExpr::typesCompatible( existing->base, added->base, SymbolTable{} ) ) {
+                        if ( ! ResolvExpr::typesCompatible( existing->base, added->base ) ) {
                                 SemanticError( added->location, "redeclaration of " + added->name );
                         }
@@ -641 +648 @@
         } else if ( existing.id->linkage.is_mangled
                         || ResolvExpr::typesCompatible(
-                                added->get_type(), existing.id->get_type(), SymbolTable{} ) ) {
+                                added->get_type(), existing.id->get_type() ) ) {
 
                 // it is a conflict if one declaration is deleted and the other is not
@@ -676 +683 @@
 }
 
-void SymbolTable::addId(
-                const DeclWithType * decl, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr,
-                const Decl * deleter ) {
+void SymbolTable::addIdCommon(
+                const DeclWithType * decl, SymbolTable::OnConflict handleConflicts,
+                const Expr * baseExpr, const Decl * deleter ) {
         SpecialFunctionKind kind = getSpecialFunctionKind(decl->name);
         if (kind == NUMBER_OF_KINDS) { // not a special decl
-                addId(decl, decl->name, idTable, handleConflicts, baseExpr, deleter);
+                addIdToTable(decl, decl->name, idTable, handleConflicts, baseExpr, deleter);
         }
         else {
@@ -694 +701 @@
                         assertf(false, "special decl with non-function type");
                 }
-                addId(decl, key, specialFunctionTable[kind], handleConflicts, baseExpr, deleter);
-        }
-}
-
-void SymbolTable::addId(
-                const DeclWithType * decl, const std::string & lookupKey, IdTable::Ptr & table, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr,
-                const Decl * deleter ) {
+                addIdToTable(decl, key, specialFunctionTable[kind], handleConflicts, baseExpr, deleter);
+        }
+}
+
+void SymbolTable::addIdToTable(
+                const DeclWithType * decl, const std::string & lookupKey,
+                IdTable::Ptr & table, SymbolTable::OnConflict handleConflicts,
+                const Expr * baseExpr, const Decl * deleter ) {
         ++*stats().add_calls;
         const std::string &name = decl->name;
@@ -777 +785 @@
 void SymbolTable::addMembers(
                 const AggregateDecl * aggr, const Expr * expr, SymbolTable::OnConflict handleConflicts ) {
-        for ( const Decl * decl : aggr->members ) {
-                if ( auto dwt = dynamic_cast< const DeclWithType * >( decl ) ) {
-                        addId( dwt, handleConflicts, expr );
-                        if ( dwt->name == "" ) {
-                                const Type * t = dwt->get_type()->stripReferences();
-                                if ( auto rty = dynamic_cast<const BaseInstType *>( t ) ) {
-                                        if ( ! dynamic_cast<const StructInstType *>(rty)
-                                                && ! dynamic_cast<const UnionInstType *>(rty) ) continue;
-                                        ResolvExpr::Cost cost = ResolvExpr::Cost::zero;
-                                        ast::ptr<ast::TypeSubstitution> tmp = expr->env;
-                                        expr = mutate_field(expr, &Expr::env, nullptr);
-                                        const Expr * base = ResolvExpr::referenceToRvalueConversion( expr, cost );
-                                        base = mutate_field(base, &Expr::env, tmp);
-
-                                        addMembers(
-                                                rty->aggr(), new MemberExpr{ base->location, dwt, base }, handleConflicts );
-                                }
-                        }
+        for ( const ptr<Decl> & decl : aggr->members ) {
+                auto dwt = decl.as<DeclWithType>();
+                if ( nullptr == dwt ) continue;
+                addIdCommon( dwt, handleConflicts, expr );
+                // Inline through unnamed struct/union members.
+                if ( "" != dwt->name ) continue;
+                const Type * t = dwt->get_type()->stripReferences();
+                if ( auto rty = dynamic_cast<const BaseInstType *>( t ) ) {
+                        if ( ! dynamic_cast<const StructInstType *>(rty)
+                                && ! dynamic_cast<const UnionInstType *>(rty) ) continue;
+                        ResolvExpr::Cost cost = ResolvExpr::Cost::zero;
+                        ast::ptr<ast::TypeSubstitution> tmp = expr->env;
+                        expr = mutate_field(expr, &Expr::env, nullptr);
+                        const Expr * base = ResolvExpr::referenceToRvalueConversion( expr, cost );
+                        base = mutate_field(base, &Expr::env, tmp);
+
+                        addMembers(
+                                rty->aggr(), new MemberExpr{ base->location, dwt, base }, handleConflicts );
                 }
         }

src/AST/SymbolTable.hpp

@@ -192 +192 @@
 
         /// common code for addId, addDeletedId, etc.
-        void addId(
-                const DeclWithType * decl, OnConflict handleConflicts, const Expr * baseExpr = nullptr,
-                const Decl * deleter = nullptr );
+        void addIdCommon(
+                const DeclWithType * decl, OnConflict handleConflicts,
+                const Expr * baseExpr = nullptr, const Decl * deleter = nullptr );
 
         /// common code for addId when special decls are placed into separate tables
-        void addId(
-                const DeclWithType * decl, const std::string & lookupKey, IdTable::Ptr & idTable, OnConflict handleConflicts, 
+        void addIdToTable(
+                const DeclWithType * decl, const std::string & lookupKey,
+                IdTable::Ptr & idTable, OnConflict handleConflicts,
                 const Expr * baseExpr = nullptr, const Decl * deleter = nullptr);
-        
+
         /// adds all of the members of the Aggregate (addWith helper)
         void addMembers( const AggregateDecl * aggr, const Expr * expr, OnConflict handleConflicts );

src/AST/TranslationUnit.hpp

@@ -10 +10 @@
 // Created On       : Tue Jun 11 15:30:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Mar 11 11:19:00 2022
-// Update Count     : 1
+// Last Modified On : Thr Mar  9 16:41:00 2023
+// Update Count     : 2
 //
 
@@ -17 +17 @@
 
 #include <map>
-#include <vector>
+#include <list>
 
 #include "Fwd.hpp"
@@ -28 +28 @@
 
         ptr<Type> sizeType;
-        const FunctionDecl * dereference;
-        const StructDecl * dtorStruct;
-        const FunctionDecl * dtorDestroy;
+        const FunctionDecl * dereference = nullptr;
+        const StructDecl * dtorStruct = nullptr;
+        const FunctionDecl * dtorDestroy = nullptr;
 };
 

src/AST/Type.cpp

@@ -10 +10 @@
 // Created On       : Mon May 13 15:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu Nov 24  9:49:00 2022
-// Update Count     : 6
+// Last Modified On : Thu Apr  6 15:59:00 2023
+// Update Count     : 7
 //
 
@@ -199 +199 @@
 
 TupleType::TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q )
-: Type( q ), types( std::move(ts) ), members() {
-        // This constructor is awkward. `TupleType` needs to contain objects so that members can be
-        // named, but members without initializer nodes end up getting constructors, which breaks
-        // things. This happens because the object decls have to be visited so that their types are
-        // kept in sync with the types listed here. Ultimately, the types listed here should perhaps
-        // be eliminated and replaced with a list-view over members. The temporary solution is to
-        // make a `ListInit` with `maybeConstructed = false`, so when the object is visited it is not
-        // constructed. Potential better solutions include:
-        //   a) Separate `TupleType` from its declarations, into `TupleDecl` and `Tuple{Inst?}Type`,
-        //      similar to the aggregate types.
-        //   b) Separate initializer nodes better, e.g. add a `MaybeConstructed` node that is replaced
-        //      by `genInit`, rather than the current boolean flag.
-        members.reserve( types.size() );
-        for ( const Type * ty : types ) {
-                members.emplace_back( new ObjectDecl{
-                        CodeLocation(), "", ty, new ListInit( CodeLocation(), {}, {}, NoConstruct ),
-                        Storage::Classes{}, Linkage::Cforall } );
-        }
-}
+: Type( q ), types( std::move(ts) ) {}
 
 bool isUnboundType(const Type * type) {

src/AST/Type.hpp

@@ -10 +10 @@
 // Created On       : Thu May 9 10:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu Nov 24  9:47:00 2022
-// Update Count     : 8
+// Last Modified On : Thu Apr  6 15:58:00 2023
+// Update Count     : 9
 //
 
@@ -265 +265 @@
 };
 
-/// Function variable arguments flag
-enum ArgumentFlag { FixedArgs, VariableArgs };
-
 /// Type of a function `[R1, R2](*)(P1, P2, P3)`
 class FunctionType final : public Type {
@@ -462 +459 @@
 public:
         std::vector<ptr<Type>> types;
-        std::vector<ptr<Decl>> members;
 
         TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q = {} );

src/AST/TypeEnvironment.cpp

@@ -178 +178 @@
 
 bool TypeEnvironment::combine(
-                const TypeEnvironment & o, OpenVarSet & open, const SymbolTable & symtab ) {
+                const TypeEnvironment & o, OpenVarSet & open ) {
         // short-circuit easy cases
         if ( o.empty() ) return true;
@@ -201 +201 @@
                         EqvClass & r = *rt;
                         // merge bindings
-                        if ( ! mergeBound( r, c, open, symtab ) ) return false;
+                        if ( ! mergeBound( r, c, open ) ) return false;
                         // merge previous unbound variables into this class, checking occurs if needed
                         if ( r.bound ) for ( const auto & u : c.vars ) {
@@ -216 +216 @@
                                 } else if ( st != rt ) {
                                         // bound, but not to the same class
-                                        if ( ! mergeClasses( rt, st, open, symtab ) ) return false;
+                                        if ( ! mergeClasses( rt, st, open ) ) return false;
                                 }       // ignore bound into the same class
                         }
@@ -280 +280 @@
 bool TypeEnvironment::bindVar(
                 const TypeInstType * typeInst, const Type * bindTo, const TypeData & data,
-                AssertionSet & need, AssertionSet & have, const OpenVarSet & open, WidenMode widen,
-                const SymbolTable & symtab
+                AssertionSet & need, AssertionSet & have, const OpenVarSet & open, WidenMode widen
 ) {
         // remove references from bound type, so that type variables can only bind to value types
@@ -300 +299 @@
                         if ( unifyInexact(
                                         newType, target, *this, need, have, open,
-                                        widen & WidenMode{ it->allowWidening, true }, symtab, common ) ) {
+                                        widen & WidenMode{ it->allowWidening, true }, common ) ) {
                                 if ( common ) {
                                         it->bound = std::move(common);
@@ -321 +320 @@
                 const TypeInstType * var1, const TypeInstType * var2, TypeData && data,
                 AssertionSet & need, AssertionSet & have, const OpenVarSet & open,
-                WidenMode widen, const SymbolTable & symtab
+                WidenMode widen
 ) {
         auto c1 = internal_lookup( *var1 );
@@ -358 +357 @@
 
                 if ( unifyInexact(
-                                newType1, newType2, *this, need, have, open, newWidenMode, symtab, common ) ) {
+                                newType1, newType2, *this, need, have, open, newWidenMode, common ) ) {
                         c1->vars.insert( c2->vars.begin(), c2->vars.end() );
                         c1->allowWidening = widen1 && widen2;
@@ -409 +408 @@
 
 bool TypeEnvironment::mergeBound(
-                EqvClass & to, const EqvClass & from, OpenVarSet & open, const SymbolTable & symtab ) {
+                EqvClass & to, const EqvClass & from, OpenVarSet & open ) {
         if ( from.bound ) {
                 if ( to.bound ) {
@@ -419 +418 @@
 
                         if ( unifyInexact(
-                                        toType, fromType, *this, need, have, open, widen, symtab, common ) ) {
+                                        toType, fromType, *this, need, have, open, widen, common ) ) {
                                 // unifies, set common type if necessary
                                 if ( common ) {
@@ -437 +436 @@
 
 bool TypeEnvironment::mergeClasses(
-        ClassList::iterator to, ClassList::iterator from, OpenVarSet & open, const SymbolTable & symtab
+        ClassList::iterator to, ClassList::iterator from, OpenVarSet & open
 ) {
         EqvClass & r = *to, & s = *from;
 
         // ensure bounds match
-        if ( ! mergeBound( r, s, open, symtab ) ) return false;
+        if ( ! mergeBound( r, s, open ) ) return false;
 
         // check safely bindable

src/AST/TypeEnvironment.hpp

@@ -63 +63 @@
 
                 int cmp = d1->var->name.compare( d2->var->name );
-                return cmp < 0 || ( cmp == 0 && d1->result < d2->result );
+                return cmp > 0 || ( cmp == 0 && d1->result < d2->result );
         }
 };
@@ -169 +169 @@
         /// Merge environment with this one, checking compatibility.
         /// Returns false if fails, but does NOT roll back partial changes.
-        bool combine( const TypeEnvironment & o, OpenVarSet & openVars, const SymbolTable & symtab );
+        bool combine( const TypeEnvironment & o, OpenVarSet & openVars );
 
         /// Add all type variables in environment to open var list
@@ -183 +183 @@
                 const TypeInstType * typeInst, const Type * bindTo, const TypeData & data,
                 AssertionSet & need, AssertionSet & have, const OpenVarSet & openVars,
-                ResolvExpr::WidenMode widen, const SymbolTable & symtab );
+                ResolvExpr::WidenMode widen );
 
         /// Binds the type classes represented by `var1` and `var2` together; will add one or both
@@ -190 +190 @@
                 const TypeInstType * var1, const TypeInstType * var2, TypeData && data,
                 AssertionSet & need, AssertionSet & have, const OpenVarSet & openVars,
-                ResolvExpr::WidenMode widen, const SymbolTable & symtab );
+                ResolvExpr::WidenMode widen );
 
         /// Disallows widening for all bindings in the environment
@@ -205 +205 @@
         /// Unifies the type bound of `to` with the type bound of `from`, returning false if fails
         bool mergeBound(
-                EqvClass & to, const EqvClass & from, OpenVarSet & openVars, const SymbolTable & symtab );
+                EqvClass & to, const EqvClass & from, OpenVarSet & openVars );
 
         /// Merges two type classes from local environment, returning false if fails
         bool mergeClasses(
-                ClassList::iterator to, ClassList::iterator from, OpenVarSet & openVars,
-                const SymbolTable & symtab );
+                ClassList::iterator to, ClassList::iterator from, OpenVarSet & openVars);
 
         /// Private lookup API; returns array index of string, or env.size() for not found

src/AST/TypeSubstitution.cpp

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Mon Jun  3 13:26:00 2017
-// Update Count     : 5
-//
+// Last Modified On : Thr May 25 11:24:00 2023
+// Update Count     : 6
+//
+
+#include "TypeSubstitution.hpp"
 
 #include "Type.hpp"   // for TypeInstType, Type, StructInstType, UnionInstType
-#include "TypeSubstitution.hpp"
+#include "Pass.hpp"   // for Pass, PureVisitor, WithGuards, WithVisitorRef
 
 namespace ast {
-
-
-// size_t TypeSubstitution::Substituter::traceId = Stats::Heap::new_stacktrace_id("TypeSubstitution");
 
 TypeSubstitution::TypeSubstitution() {
@@ -119 +118 @@
 }
 
+// definitition must happen after PassVisitor is included so that WithGuards can be used
+struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter>, public PureVisitor {
+        //static size_t traceId;
+
+        Substituter( const TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
+
+        const Type * postvisit( const TypeInstType * aggregateUseType );
+
+        /// Records type variable bindings from forall-statements
+        void previsit( const FunctionType * type );
+        /// Records type variable bindings from forall-statements and instantiations of generic types
+        // void handleAggregateType( const BaseInstType * type );
+
+        // void previsit( const StructInstType * aggregateUseType );
+        // void previsit( const UnionInstType * aggregateUseType );
+
+        const TypeSubstitution & sub;
+        int subCount = 0;
+        bool freeOnly;
+        typedef std::unordered_set< TypeEnvKey > BoundVarsType;
+        BoundVarsType boundVars;
+};
+
+// size_t TypeSubstitution::Substituter::traceId = Stats::Heap::new_stacktrace_id("TypeSubstitution");
+
 void TypeSubstitution::normalize() {
         Pass<Substituter> sub( *this, true );
@@ -128 +152 @@
                 }
         } while ( sub.core.subCount );
+}
+
+TypeSubstitution::ApplyResult<Node> TypeSubstitution::applyBase(
+                const Node * input, bool isFree ) const {
+        assert( input );
+        Pass<Substituter> sub( *this, isFree );
+        const Node * output = input->accept( sub );
+        return { output, sub.core.subCount };
 }
 

src/AST/TypeSubstitution.hpp

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Apr 30 22:52:47 2019
-// Update Count     : 9
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr May 25 12:31:00 2023
+// Update Count     : 10
 //
 
@@ -46 +46 @@
         TypeSubstitution &operator=( const TypeSubstitution &other );
 
-        template< typename SynTreeClass >
+        template< typename node_t >
         struct ApplyResult {
-                ast::ptr<SynTreeClass> node;
+                ast::ptr<node_t> node;
                 int count;
         };
 
-        template< typename SynTreeClass > ApplyResult<SynTreeClass> apply( const SynTreeClass * input ) const;
-        template< typename SynTreeClass > ApplyResult<SynTreeClass> applyFree( const SynTreeClass * input ) const;
+        template< typename node_t >
+        ApplyResult<node_t> apply( const node_t * input ) const {
+                ApplyResult<Node> ret = applyBase( input, false );
+                return { ret.node.strict_as<node_t>(), ret.count };
+        }
 
         template< typename node_t, enum Node::ref_type ref_t >
         int apply( ptr_base< node_t, ref_t > & input ) const {
-                const node_t * p = input.get();
-                auto ret = apply(p);
-                input = ret.node;
+                ApplyResult<Node> ret = applyBase( input.get(), false );
+                input = ret.node.strict_as<node_t>();
                 return ret.count;
+        }
+
+        template< typename node_t >
+        ApplyResult<node_t> applyFree( const node_t * input ) const {
+                ApplyResult<Node> ret = applyBase( input, true );
+                return { ret.node.strict_as<node_t>(), ret.count };
         }
 
         template< typename node_t, enum Node::ref_type ref_t >
         int applyFree( ptr_base< node_t, ref_t > & input ) const {
-                const node_t * p = input.get();
-                auto ret = applyFree(p);
-                input = ret.node;
+                ApplyResult<Node> ret = applyBase( input.get(), true );
+                input = ret.node.strict_as<node_t>();
                 return ret.count;
         }
@@ -97 +104 @@
         // Mutator that performs the substitution
         struct Substituter;
+        ApplyResult<Node> applyBase( const Node * input, bool isFree ) const;
 
         // TODO: worry about traversing into a forall-qualified function type or type decl with assertions
@@ -158 +166 @@
 } // namespace ast
 
-// include needs to happen after TypeSubstitution is defined so that both TypeSubstitution and
-// PassVisitor are defined before PassVisitor implementation accesses TypeSubstitution internals.
-#include "Pass.hpp"
-#include "Copy.hpp"
-
-namespace ast {
-
-// definitition must happen after PassVisitor is included so that WithGuards can be used
-struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter>, public PureVisitor {
-                static size_t traceId;
-
-                Substituter( const TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
-
-                const Type * postvisit( const TypeInstType * aggregateUseType );
-
-                /// Records type variable bindings from forall-statements
-                void previsit( const FunctionType * type );
-                /// Records type variable bindings from forall-statements and instantiations of generic types
-                // void handleAggregateType( const BaseInstType * type );
-
-                // void previsit( const StructInstType * aggregateUseType );
-                // void previsit( const UnionInstType * aggregateUseType );
-
-                const TypeSubstitution & sub;
-                int subCount = 0;
-                bool freeOnly;
-                typedef std::unordered_set< TypeEnvKey > BoundVarsType;
-                BoundVarsType boundVars;
-
-};
-
-template< typename SynTreeClass >
-TypeSubstitution::ApplyResult<SynTreeClass> TypeSubstitution::apply( const SynTreeClass * input ) const {
-        assert( input );
-        Pass<Substituter> sub( *this, false );
-        input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
-        return { input, sub.core.subCount };
-}
-
-template< typename SynTreeClass >
-TypeSubstitution::ApplyResult<SynTreeClass> TypeSubstitution::applyFree( const SynTreeClass * input ) const {
-        assert( input );
-        Pass<Substituter> sub( *this, true );
-        input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
-        return { input, sub.core.subCount };
-}
-
-} // namespace ast
-
 // Local Variables: //
 // tab-width: 4 //

src/AST/Visitor.hpp

@@ -50 +50 @@
     virtual const ast::FinallyClause *    visit( const ast::FinallyClause        * ) = 0;
     virtual const ast::Stmt *             visit( const ast::SuspendStmt          * ) = 0;
+    virtual const ast::WhenClause *       visit( const ast::WhenClause           * ) = 0;
     virtual const ast::Stmt *             visit( const ast::WaitForStmt          * ) = 0;
     virtual const ast::WaitForClause *    visit( const ast::WaitForClause        * ) = 0;
+    virtual const ast::Stmt *             visit( const ast::WaitUntilStmt        * ) = 0;
     virtual const ast::Decl *             visit( const ast::WithStmt             * ) = 0;
     virtual const ast::NullStmt *         visit( const ast::NullStmt             * ) = 0;

src/AST/porting.md

@@ -213 +213 @@
 * `get_statement()` exclusively used for code location, replaced with `CodeLocation` field
 
-`CaseStmt`
+`CaseStmt` => `CaseClause`
 * `_isDefault` has been removed
   * `isDefault` calculates value from `cond`
@@ -227 +227 @@
 * `block` -> `body` and `finallyBlock` -> `finally`
 
-`ThrowStmt` `CatchStmt`
+`ThrowStmt` and `CatchStmt` => `CatchClause`
 * moved `Kind` enums to shared `ast::ExceptionKind` enum
 
-`FinallyStmt`
+`FinallyStmt` => `FinallyClause`
 * `block` -> `body`
 
@@ -280 +280 @@
 * Template class, with specializations and using to implement some other types:
   * `StructInstType`, `UnionInstType` & `EnumInstType`
+  * `baseStruct`, `baseUnion` & `baseEnum` => `base`
 
 `TypeInstType`