Changeset 8a930c03 for src

Timestamp:

Jun 12, 2023, 12:05:58 PM (2 years ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

fec8bd1

Parents:

2b78949 (diff), 38e266ca (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' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• AST/DeclReplacer.hpp (modified) (1 diff)
• AST/Pass.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (8 diffs)
• AST/Pass.proto.hpp (modified) (1 diff)
• AST/Print.cpp (modified) (1 diff)
• AST/SymbolTable.cpp (modified) (8 diffs)
• AST/SymbolTable.hpp (modified) (5 diffs)
• AST/TypeEnvironment.cpp (modified) (10 diffs)
• AST/TypeEnvironment.hpp (modified) (4 diffs)
• AST/TypeSubstitution.cpp (modified) (3 diffs)
• AST/TypeSubstitution.hpp (modified) (4 diffs)
• AST/Util.cpp (modified) (2 diffs)
• Concurrency/Actors.cpp (modified) (7 diffs)
• Concurrency/Waituntil.cpp (modified) (11 diffs)
• ControlStruct/ExceptDeclNew.cpp (modified) (1 diff)
• GenPoly/InstantiateGenericNew.cpp (modified) (1 diff)
• GenPoly/LvalueNew.cpp (modified) (4 diffs)
• GenPoly/SpecializeNew.cpp (modified) (1 diff)
• InitTweak/InitTweak.cc (modified) (1 diff)
• MakeLibCfaNew.cpp (modified) (1 diff)
• Parser/lex.ll (modified) (2 diffs)
• Parser/parser.yy (modified) (31 diffs)
• ResolvExpr/CandidateFinder.cpp (modified) (9 diffs)
• ResolvExpr/CastCost.cc (modified) (2 diffs)
• ResolvExpr/CommonType.cc (modified) (21 diffs)
• ResolvExpr/CommonType.hpp (modified) (1 diff)
• ResolvExpr/ConversionCost.cc (modified) (4 diffs)
• ResolvExpr/PolyCost.cc (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (5 diffs)
• ResolvExpr/SatisfyAssertions.cpp (modified) (3 diffs)
• ResolvExpr/Unify.cc (modified) (30 diffs)
• ResolvExpr/Unify.h (modified) (1 diff)
• SymTab/Autogen.h (modified) (2 diffs)
• SymTab/GenImplicitCall.cpp (modified) (2 diffs)
• SymTab/GenImplicitCall.hpp (modified) (2 diffs)
• Tuples/Explode.cc (modified) (1 diff)
• Validate/Autogen.cpp (modified) (5 diffs)
• Validate/FixQualifiedTypes.cpp (modified) (1 diff)
• Validate/GenericParameter.cpp (modified) (1 diff)
• Validate/HoistStruct.cpp (modified) (6 diffs)
• Validate/ReplaceTypedef.cpp (modified) (2 diffs)
• Virtual/ExpandCasts.cc (modified) (1 diff)
• main.cc (modified) (1 diff)

src/AST/DeclReplacer.hpp

@@ -18 +18 @@
 #include <unordered_map>
 
-#include "Node.hpp"
+namespace ast {
+        class DeclWithType;
+        class Expr;
+        class Node;
+        class TypeDecl;
+}
 
 namespace ast {
-        class DeclWithType;
-        class TypeDecl;
-        class Expr;
 
-        namespace DeclReplacer {
-                using DeclMap = std::unordered_map< const DeclWithType *, const DeclWithType * >;
-                using TypeMap = std::unordered_map< const TypeDecl *, const TypeDecl * >;
-                using ExprMap = std::unordered_map< const DeclWithType *, const Expr * >;
+namespace DeclReplacer {
 
-                const Node * replace( const Node * node, const DeclMap & declMap, bool debug = false );
-                const Node * replace( const Node * node, const TypeMap & typeMap, bool debug = false );
-                const Node * replace( const Node * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
-                const Node * replace( const Node * node, const ExprMap & exprMap);
-        }
+using DeclMap = std::unordered_map< const DeclWithType *, const DeclWithType * >;
+using TypeMap = std::unordered_map< const TypeDecl *, const TypeDecl * >;
+using ExprMap = std::unordered_map< const DeclWithType *, const Expr * >;
+
+const Node * replace( const Node * node, const DeclMap & declMap, bool debug = false );
+const Node * replace( const Node * node, const TypeMap & typeMap, bool debug = false );
+const Node * replace( const Node * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
+const Node * replace( const Node * node, const ExprMap & exprMap);
+
+}
+
 }
 

src/AST/Pass.hpp

@@ -414 +414 @@
 };
 
-/// Use when the templated visitor should update the symbol table
+/// Use when the templated visitor should update the symbol table,
+/// that is, when your pass core needs to query the symbol table.
+/// Expected setups:
+/// - For master passes that kick off at the compilation unit
+///   - before resolver: extend WithSymbolTableX<IgnoreErrors>
+///   - after resolver: extend WithSymbolTable and use defaults
+///   - (FYI, for completeness, the resolver's main pass uses ValidateOnAdd when it kicks off)
+/// - For helper passes that kick off at arbitrary points in the AST:
+///   - take an existing symbol table as a parameter, extend WithSymbolTable,
+///     and construct with WithSymbolTable(const SymbolTable &)
 struct WithSymbolTable {
-        SymbolTable symtab;
+        WithSymbolTable(const ast::SymbolTable & from) : symtab(from) {}
+        WithSymbolTable(ast::SymbolTable::ErrorDetection errorMode = ast::SymbolTable::ErrorDetection::AssertClean) : symtab(errorMode) {}
+        ast::SymbolTable symtab;
+};
+template <ast::SymbolTable::ErrorDetection errorMode>
+struct WithSymbolTableX : WithSymbolTable {
+        WithSymbolTableX() : WithSymbolTable(errorMode) {}
 };
 

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
@@ -71 +72 @@
                 template<typename it_t, template <class...> class container_t>
                 static inline void take_all( it_t it, container_t<ast::ptr<ast::Decl>> * decls, bool * mutated = nullptr ) {
-                        if(empty(decls)) return;
+                        if ( empty( decls ) ) return;
 
                         std::transform(decls->begin(), decls->end(), it, [](const ast::Decl * decl) -> auto {
@@ -77 +78 @@
                                 });
                         decls->clear();
-                        if(mutated) *mutated = true;
+                        if ( mutated ) *mutated = true;
                 }
 
                 template<typename it_t, template <class...> class container_t>
                 static inline void take_all( it_t it, container_t<ast::ptr<ast::Stmt>> * stmts, bool * mutated = nullptr ) {
-                        if(empty(stmts)) return;
+                        if ( empty( stmts ) ) return;
 
                         std::move(stmts->begin(), stmts->end(), it);
                         stmts->clear();
-                        if(mutated) *mutated = true;
+                        if ( mutated ) *mutated = true;
                 }
 
@@ -92 +93 @@
                 /// Check if should be skipped, different for pointers and containers
                 template<typename node_t>
-                bool skip( const ast::ptr<node_t> & val) {
+                bool skip( const ast::ptr<node_t> & val ) {
                         return !val;
                 }
@@ -109 +110 @@
 
                 template<typename node_t>
-                const node_t & get( const node_t & val, long) {
+                const node_t & get( const node_t & val, long ) {
                         return val;
                 }
@@ -125 +126 @@
                 }
         }
-
-        template< typename core_t >
-        template< typename node_t >
-        auto ast::Pass< core_t >::call_accept( const node_t * node )
-                -> typename ast::Pass< core_t >::template generic_call_accept_result<node_t>::type
-        {
-                __pedantic_pass_assert( __visit_children() );
-                __pedantic_pass_assert( node );
-
-                static_assert( !std::is_base_of<ast::Expr, node_t>::value, "ERROR");
-                static_assert( !std::is_base_of<ast::Stmt, node_t>::value, "ERROR");
-
-                auto nval = node->accept( *this );
-                __pass::result1<
-                        typename std::remove_pointer< decltype( node->accept(*this) ) >::type
-                > res;
-                res.differs = nval != node;
-                res.value = nval;
-                return res;
-        }
-
-        template< typename core_t >
-        __pass::template result1<ast::Expr> ast::Pass< core_t >::call_accept( const ast::Expr * expr ) {
-                __pedantic_pass_assert( __visit_children() );
-                __pedantic_pass_assert( expr );
-
-                auto nval = expr->accept( *this );
-                return { nval != expr, nval };
-        }
-
-        template< typename core_t >
-        __pass::template result1<ast::Stmt> ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) {
-                __pedantic_pass_assert( __visit_children() );
-                __pedantic_pass_assert( stmt );
-
-                const ast::Stmt * nval = stmt->accept( *this );
-                return { nval != stmt, nval };
-        }
-
-        template< typename core_t >
-        __pass::template result1<ast::Expr> ast::Pass< core_t >::call_accept_top( const ast::Expr * expr ) {
-                __pedantic_pass_assert( __visit_children() );
-                __pedantic_pass_assert( expr );
-
-                const ast::TypeSubstitution ** typeSubs_ptr = __pass::typeSubs( core, 0 );
-                if ( typeSubs_ptr && expr->env ) {
-                        *typeSubs_ptr = expr->env;
-                }
-
-                auto nval = expr->accept( *this );
-                return { nval != expr, nval };
-        }
-
-        template< typename core_t >
-        __pass::template result1<ast::Stmt> ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
-                __pedantic_pass_assert( __visit_children() );
-                __pedantic_pass_assert( stmt );
-
-                // add a few useful symbols to the scope
-                using __pass::empty;
-
-                // get the stmts/decls that will need to be spliced in
-                auto stmts_before = __pass::stmtsToAddBefore( core, 0 );
-                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0 );
-                auto decls_before = __pass::declsToAddBefore( core, 0 );
-                auto decls_after  = __pass::declsToAddAfter ( core, 0 );
-
-                // These may be modified by subnode but most be restored once we exit this statemnet.
-                ValueGuardPtr< const ast::TypeSubstitution * > __old_env         ( __pass::typeSubs( core, 0 ) );
-                ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
-                ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after  );
-                ValueGuardPtr< typename std::remove_pointer< decltype(decls_before) >::type > __old_stmts_before( decls_before );
-                ValueGuardPtr< typename std::remove_pointer< decltype(decls_after ) >::type > __old_stmts_after ( decls_after  );
-
-                // Now is the time to actually visit the node
-                const ast::Stmt * nstmt = stmt->accept( *this );
-
-                // If the pass doesn't want to add anything then we are done
-                if( empty(stmts_before) && empty(stmts_after) && empty(decls_before) && empty(decls_after) ) {
-                        return { nstmt != stmt, nstmt };
-                }
-
-                // Make sure that it is either adding statements or declartions but not both
-                // this is because otherwise the order would be awkward to predict
-                assert(( empty( stmts_before ) && empty( stmts_after ))
-                    || ( empty( decls_before ) && empty( decls_after )) );
-
-                // Create a new Compound Statement to hold the new decls/stmts
-                ast::CompoundStmt * compound = new ast::CompoundStmt( stmt->location );
-
-                // Take all the declarations that go before
-                __pass::take_all( std::back_inserter( compound->kids ), decls_before );
-                __pass::take_all( std::back_inserter( compound->kids ), stmts_before );
-
-                // Insert the original declaration
-                compound->kids.emplace_back( nstmt );
-
-                // Insert all the declarations that go before
-                __pass::take_all( std::back_inserter( compound->kids ), decls_after );
-                __pass::take_all( std::back_inserter( compound->kids ), stmts_after );
-
-                return {true, compound};
-        }
-
-        template< typename core_t >
-        template< template <class...> class container_t >
-        __pass::template resultNstmt<container_t> ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
-                __pedantic_pass_assert( __visit_children() );
-                if( statements.empty() ) return {};
-
-                // We are going to aggregate errors for all these statements
-                SemanticErrorException errors;
-
-                // add a few useful symbols to the scope
-                using __pass::empty;
-
-                // get the stmts/decls that will need to be spliced in
-                auto stmts_before = __pass::stmtsToAddBefore( core, 0 );
-                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0 );
-                auto decls_before = __pass::declsToAddBefore( core, 0 );
-                auto decls_after  = __pass::declsToAddAfter ( core, 0 );
-
-                // These may be modified by subnode but most be restored once we exit this statemnet.
-                ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
-                ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after  );
-                ValueGuardPtr< typename std::remove_pointer< decltype(decls_before) >::type > __old_stmts_before( decls_before );
-                ValueGuardPtr< typename std::remove_pointer< decltype(decls_after ) >::type > __old_stmts_after ( decls_after  );
-
-                // update pass statitistics
-                pass_visitor_stats.depth++;
-                pass_visitor_stats.max->push(pass_visitor_stats.depth);
-                pass_visitor_stats.avg->push(pass_visitor_stats.depth);
-
-                __pass::resultNstmt<container_t> new_kids;
-                for( auto value : enumerate( statements ) ) {
-                        try {
-                                size_t i = value.idx;
-                                const Stmt * stmt = value.val;
-                                __pedantic_pass_assert( stmt );
-                                const ast::Stmt * new_stmt = stmt->accept( *this );
-                                assert( new_stmt );
-                                if(new_stmt != stmt ) { new_kids.differs = true; }
-
-                                // Make sure that it is either adding statements or declartions but not both
-                                // this is because otherwise the order would be awkward to predict
-                                assert(( empty( stmts_before ) && empty( stmts_after ))
-                                    || ( empty( decls_before ) && empty( decls_after )) );
-
-                                // Take all the statements which should have gone after, N/A for first iteration
-                                new_kids.take_all( decls_before );
-                                new_kids.take_all( stmts_before );
-
-                                // Now add the statement if there is one
-                                if(new_stmt != stmt) {
-                                        new_kids.values.emplace_back( new_stmt, i, false );
-                                } else {
-                                        new_kids.values.emplace_back( nullptr, i, true );
-                                }
-
-                                // Take all the declarations that go before
-                                new_kids.take_all( decls_after );
-                                new_kids.take_all( stmts_after );
+}
+
+template< typename core_t >
+template< typename node_t >
+auto ast::Pass< core_t >::call_accept( const node_t * node ) ->
+        typename ast::Pass< core_t >::template generic_call_accept_result<node_t>::type
+{
+        __pedantic_pass_assert( __visit_children() );
+        __pedantic_pass_assert( node );
+
+        static_assert( !std::is_base_of<ast::Expr, node_t>::value, "ERROR" );
+        static_assert( !std::is_base_of<ast::Stmt, node_t>::value, "ERROR" );
+
+        auto nval = node->accept( *this );
+        __pass::result1<
+                typename std::remove_pointer< decltype( node->accept(*this) ) >::type
+        > res;
+        res.differs = nval != node;
+        res.value = nval;
+        return res;
+}
+
+template< typename core_t >
+ast::__pass::template result1<ast::Expr> ast::Pass< core_t >::call_accept( const ast::Expr * expr ) {
+        __pedantic_pass_assert( __visit_children() );
+        __pedantic_pass_assert( expr );
+
+        auto nval = expr->accept( *this );
+        return { nval != expr, nval };
+}
+
+template< typename core_t >
+ast::__pass::template result1<ast::Stmt> ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) {
+        __pedantic_pass_assert( __visit_children() );
+        __pedantic_pass_assert( stmt );
+
+        const ast::Stmt * nval = stmt->accept( *this );
+        return { nval != stmt, nval };
+}
+
+template< typename core_t >
+ast::__pass::template result1<ast::Expr> ast::Pass< core_t >::call_accept_top( const ast::Expr * expr ) {
+        __pedantic_pass_assert( __visit_children() );
+        __pedantic_pass_assert( expr );
+
+        const ast::TypeSubstitution ** typeSubs_ptr = __pass::typeSubs( core, 0 );
+        if ( typeSubs_ptr && expr->env ) {
+                *typeSubs_ptr = expr->env;
+        }
+
+        auto nval = expr->accept( *this );
+        return { nval != expr, nval };
+}
+
+template< typename core_t >
+ast::__pass::template result1<ast::Stmt> ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
+        __pedantic_pass_assert( __visit_children() );
+        __pedantic_pass_assert( stmt );
+
+        // add a few useful symbols to the scope
+        using __pass::empty;
+
+        // get the stmts/decls that will need to be spliced in
+        auto stmts_before = __pass::stmtsToAddBefore( core, 0 );
+        auto stmts_after  = __pass::stmtsToAddAfter ( core, 0 );
+        auto decls_before = __pass::declsToAddBefore( core, 0 );
+        auto decls_after  = __pass::declsToAddAfter ( core, 0 );
+
+        // These may be modified by subnode but most be restored once we exit this statemnet.
+        ValueGuardPtr< const ast::TypeSubstitution * > __old_env         ( __pass::typeSubs( core, 0 ) );
+        ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
+        ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after  );
+        ValueGuardPtr< typename std::remove_pointer< decltype(decls_before) >::type > __old_stmts_before( decls_before );
+        ValueGuardPtr< typename std::remove_pointer< decltype(decls_after ) >::type > __old_stmts_after ( decls_after  );
+
+        // Now is the time to actually visit the node
+        const ast::Stmt * nstmt = stmt->accept( *this );
+
+        // If the pass doesn't want to add anything then we are done
+        if ( empty(stmts_before) && empty(stmts_after) && empty(decls_before) && empty(decls_after) ) {
+                return { nstmt != stmt, nstmt };
+        }
+
+        // Make sure that it is either adding statements or declartions but not both
+        // this is because otherwise the order would be awkward to predict
+        assert(( empty( stmts_before ) && empty( stmts_after ))
+            || ( empty( decls_before ) && empty( decls_after )) );
+
+        // Create a new Compound Statement to hold the new decls/stmts
+        ast::CompoundStmt * compound = new ast::CompoundStmt( stmt->location );
+
+        // Take all the declarations that go before
+        __pass::take_all( std::back_inserter( compound->kids ), decls_before );
+        __pass::take_all( std::back_inserter( compound->kids ), stmts_before );
+
+        // Insert the original declaration
+        compound->kids.emplace_back( nstmt );
+
+        // Insert all the declarations that go before
+        __pass::take_all( std::back_inserter( compound->kids ), decls_after );
+        __pass::take_all( std::back_inserter( compound->kids ), stmts_after );
+
+        return { true, compound };
+}
+
+template< typename core_t >
+template< template <class...> class container_t >
+ast::__pass::template resultNstmt<container_t> ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
+        __pedantic_pass_assert( __visit_children() );
+        if ( statements.empty() ) return {};
+
+        // We are going to aggregate errors for all these statements
+        SemanticErrorException errors;
+
+        // add a few useful symbols to the scope
+        using __pass::empty;
+
+        // get the stmts/decls that will need to be spliced in
+        auto stmts_before = __pass::stmtsToAddBefore( core, 0 );
+        auto stmts_after  = __pass::stmtsToAddAfter ( core, 0 );
+        auto decls_before = __pass::declsToAddBefore( core, 0 );
+        auto decls_after  = __pass::declsToAddAfter ( core, 0 );
+
+        // These may be modified by subnode but most be restored once we exit this statemnet.
+        ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
+        ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after  );
+        ValueGuardPtr< typename std::remove_pointer< decltype(decls_before) >::type > __old_stmts_before( decls_before );
+        ValueGuardPtr< typename std::remove_pointer< decltype(decls_after ) >::type > __old_stmts_after ( decls_after  );
+
+        // update pass statitistics
+        pass_visitor_stats.depth++;
+        pass_visitor_stats.max->push(pass_visitor_stats.depth);
+        pass_visitor_stats.avg->push(pass_visitor_stats.depth);
+
+        __pass::resultNstmt<container_t> new_kids;
+        for ( auto value : enumerate( statements ) ) {
+                try {
+                        size_t i = value.idx;
+                        const Stmt * stmt = value.val;
+                        __pedantic_pass_assert( stmt );
+                        const ast::Stmt * new_stmt = stmt->accept( *this );
+                        assert( new_stmt );
+                        if ( new_stmt != stmt ) { new_kids.differs = true; }
+
+                        // Make sure that it is either adding statements or declartions but not both
+                        // this is because otherwise the order would be awkward to predict
+                        assert(( empty( stmts_before ) && empty( stmts_after ))
+                            || ( empty( decls_before ) && empty( decls_after )) );
+
+                        // Take all the statements which should have gone after, N/A for first iteration
+                        new_kids.take_all( decls_before );
+                        new_kids.take_all( stmts_before );
+
+                        // Now add the statement if there is one
+                        if ( new_stmt != stmt ) {
+                                new_kids.values.emplace_back( new_stmt, i, false );
+                        } else {
+                                new_kids.values.emplace_back( nullptr, i, true );
                         }
-                        catch ( SemanticErrorException &e ) {
-                                errors.append( e );
+
+                        // Take all the declarations that go before
+                        new_kids.take_all( decls_after );
+                        new_kids.take_all( stmts_after );
+                } catch ( SemanticErrorException &e ) {
+                        errors.append( e );
+                }
+        }
+        pass_visitor_stats.depth--;
+        if ( !errors.isEmpty() ) { throw errors; }
+
+        return new_kids;
+}
+
+template< typename core_t >
+template< template <class...> class container_t, typename node_t >
+ast::__pass::template resultN<container_t, node_t> ast::Pass< core_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
+        __pedantic_pass_assert( __visit_children() );
+        if ( container.empty() ) return {};
+        SemanticErrorException errors;
+
+        pass_visitor_stats.depth++;
+        pass_visitor_stats.max->push(pass_visitor_stats.depth);
+        pass_visitor_stats.avg->push(pass_visitor_stats.depth);
+
+        bool mutated = false;
+        container_t<ptr<node_t>> new_kids;
+        for ( const node_t * node : container ) {
+                try {
+                        __pedantic_pass_assert( node );
+                        const node_t * new_stmt = strict_dynamic_cast< const node_t * >( node->accept( *this ) );
+                        if ( new_stmt != node ) {
+                                mutated = true;
+                                new_kids.emplace_back( new_stmt );
+                        } else {
+                                new_kids.emplace_back( nullptr );
                         }
-                }
-                pass_visitor_stats.depth--;
-                if ( !errors.isEmpty() ) { throw errors; }
-
-                return new_kids;
-        }
-
-        template< typename core_t >
-        template< template <class...> class container_t, typename node_t >
-        __pass::template resultN<container_t, node_t> ast::Pass< core_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
-                __pedantic_pass_assert( __visit_children() );
-                if( container.empty() ) return {};
-                SemanticErrorException errors;
-
-                pass_visitor_stats.depth++;
-                pass_visitor_stats.max->push(pass_visitor_stats.depth);
-                pass_visitor_stats.avg->push(pass_visitor_stats.depth);
-
-                bool mutated = false;
-                container_t<ptr<node_t>> new_kids;
-                for ( const node_t * node : container ) {
-                        try {
-                                __pedantic_pass_assert( node );
-                                const node_t * new_stmt = strict_dynamic_cast< const node_t * >( node->accept( *this ) );
-                                if(new_stmt != node ) {
-                                        mutated = true;
-                                        new_kids.emplace_back( new_stmt );
-                                } else {
-                                        new_kids.emplace_back( nullptr );
-                                }
-
-                        }
-                        catch( SemanticErrorException &e ) {
-                                errors.append( e );
-                        }
-                }
-
-                __pedantic_pass_assert( new_kids.size() == container.size() );
-                pass_visitor_stats.depth--;
-                if ( ! errors.isEmpty() ) { throw errors; }
-
-                return ast::__pass::resultN<container_t, node_t>{ mutated, new_kids };
-        }
-
-        template< typename core_t >
-        template<typename node_t, typename super_t, typename field_t>
-        void ast::Pass< core_t >::maybe_accept(
-                const node_t * & parent,
-                field_t super_t::*field
-        ) {
-                static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
-
-                if(__pass::skip(parent->*field)) return;
-                const auto & old_val = __pass::get(parent->*field, 0);
-
-                static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR");
-
-                auto new_val = call_accept( old_val );
-
-                static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value /* || std::is_same<int, decltype(old_val)>::value */, "ERROR");
-
-                if( new_val.differs ) {
-                        auto new_parent = __pass::mutate<core_t>(parent);
-                        new_val.apply(new_parent, field);
-                        parent = new_parent;
-                }
-        }
-
-        template< typename core_t >
-        template<typename node_t, typename super_t, typename field_t>
-        void ast::Pass< core_t >::maybe_accept_top(
-                const node_t * & parent,
-                field_t super_t::*field
-        ) {
-                static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
-
-                if(__pass::skip(parent->*field)) return;
-                const auto & old_val = __pass::get(parent->*field, 0);
-
-                static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR");
-
-                auto new_val = call_accept_top( old_val );
-
-                static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value /* || std::is_same<int, decltype(old_val)>::value */, "ERROR");
-
-                if( new_val.differs ) {
-                        auto new_parent = __pass::mutate<core_t>(parent);
-                        new_val.apply(new_parent, field);
-                        parent = new_parent;
-                }
-        }
-
-        template< typename core_t >
-        template<typename node_t, typename super_t, typename field_t>
-        void ast::Pass< core_t >::maybe_accept_as_compound(
-                const node_t * & parent,
-                field_t super_t::*child
-        ) {
-                static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
-
-                if(__pass::skip(parent->*child)) return;
-                const auto & old_val = __pass::get(parent->*child, 0);
-
-                static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR");
-
-                auto new_val = call_accept_as_compound( old_val );
-
-                static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR");
-
-                if( new_val.differs ) {
-                        auto new_parent = __pass::mutate<core_t>(parent);
-                        new_val.apply( new_parent, child );
-                        parent = new_parent;
-                }
-        }
-
+                } catch ( SemanticErrorException &e ) {
+                        errors.append( e );
+                }
+        }
+
+        __pedantic_pass_assert( new_kids.size() == container.size() );
+        pass_visitor_stats.depth--;
+        if ( !errors.isEmpty() ) { throw errors; }
+
+        return ast::__pass::resultN<container_t, node_t>{ mutated, new_kids };
+}
+
+template< typename core_t >
+template<typename node_t, typename super_t, typename field_t>
+void ast::Pass< core_t >::maybe_accept(
+        const node_t * & parent,
+        field_t super_t::*field
+) {
+        static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
+
+        if ( __pass::skip( parent->*field ) ) return;
+        const auto & old_val = __pass::get(parent->*field, 0);
+
+        static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR" );
+
+        auto new_val = call_accept( old_val );
+
+        static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value /* || std::is_same<int, decltype(old_val)>::value */, "ERROR" );
+
+        if ( new_val.differs ) {
+                auto new_parent = __pass::mutate<core_t>(parent);
+                new_val.apply(new_parent, field);
+                parent = new_parent;
+        }
+}
+
+template< typename core_t >
+template<typename node_t, typename super_t, typename field_t>
+void ast::Pass< core_t >::maybe_accept_top(
+        const node_t * & parent,
+        field_t super_t::*field
+) {
+        static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
+
+        if ( __pass::skip( parent->*field ) ) return;
+        const auto & old_val = __pass::get(parent->*field, 0);
+
+        static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR" );
+
+        auto new_val = call_accept_top( old_val );
+
+        static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value /* || std::is_same<int, decltype(old_val)>::value */, "ERROR" );
+
+        if ( new_val.differs ) {
+                auto new_parent = __pass::mutate<core_t>(parent);
+                new_val.apply(new_parent, field);
+                parent = new_parent;
+        }
+}
+
+template< typename core_t >
+template<typename node_t, typename super_t, typename field_t>
+void ast::Pass< core_t >::maybe_accept_as_compound(
+        const node_t * & parent,
+        field_t super_t::*child
+) {
+        static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
+
+        if ( __pass::skip( parent->*child ) ) return;
+        const auto & old_val = __pass::get(parent->*child, 0);
+
+        static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR" );
+
+        auto new_val = call_accept_as_compound( old_val );
+
+        static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR" );
+
+        if ( new_val.differs ) {
+                auto new_parent = __pass::mutate<core_t>(parent);
+                new_val.apply( new_parent, child );
+                parent = new_parent;
+        }
 }
 
@@ -760 +757 @@
 
         if ( __visit_children() ) {
-                // Do not enter (or leave) a new scope if atFunctionTop. Remember to save the result.
-                auto guard1 = makeFuncGuard( [this, enterScope = !this->atFunctionTop]() {
-                        if ( enterScope ) {
-                                __pass::symtab::enter(core, 0);
-                        }
-                }, [this, leaveScope = !this->atFunctionTop]() {
-                        if ( leaveScope ) {
-                                __pass::symtab::leave(core, 0);
-                        }
-                });
-                ValueGuard< bool > guard2( atFunctionTop );
-                atFunctionTop = false;
-                guard_scope guard3 { *this };
-                maybe_accept( node, &CompoundStmt::kids );
+                // Do not enter (or leave) a new symbol table scope if atFunctionTop.
+                // But always enter (and leave) a new general scope.
+                if ( atFunctionTop ) {
+                        ValueGuard< bool > guard1( atFunctionTop );
+                        atFunctionTop = false;
+                        guard_scope guard2( *this );
+                        maybe_accept( node, &CompoundStmt::kids );
+                } else {
+                        guard_symtab guard1( *this );
+                        guard_scope guard2( *this );
+                        maybe_accept( node, &CompoundStmt::kids );
+                }
         }
 

src/AST/Pass.proto.hpp

@@ -27 +27 @@
 
 #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

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;

src/AST/SymbolTable.cpp

@@ -18 +18 @@
 #include <cassert>
 
+#include "Copy.hpp"
 #include "Decl.hpp"
 #include "Expr.hpp"
@@ -87 +88 @@
 }
 
-SymbolTable::SymbolTable()
+SymbolTable::SymbolTable( ErrorDetection errorMode )
 : idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable(),
-  prevScope(), scope( 0 ), repScope( 0 ) { ++*stats().count; }
+  prevScope(), scope( 0 ), repScope( 0 ), errorMode(errorMode) { ++*stats().count; }
 
 SymbolTable::~SymbolTable() { stats().size->push( idTable ? idTable->size() : 0 ); }
+
+void SymbolTable::OnFindError( CodeLocation location, std::string error ) const {
+        assertf( errorMode != AssertClean, "Name collision/redefinition, found during a compilation phase where none should be possible.  Detail: %s", error.c_str() );
+        if (errorMode == ValidateOnAdd) {
+                SemanticError(location, error);
+        }
+        assertf( errorMode == IgnoreErrors, "Unrecognized symbol-table error mode %d", errorMode );
+}
 
 void SymbolTable::enterScope() {
@@ -268 +277 @@
 }
 
-namespace {
-        /// true if redeclaration conflict between two types
-        bool addedTypeConflicts( const NamedTypeDecl * existing, const NamedTypeDecl * added ) {
-                if ( existing->base == nullptr ) {
-                        return false;
-                } else if ( added->base == nullptr ) {
-                        return true;
-                } else {
-                        // typedef redeclarations are errors only if types are different
-                        if ( ! ResolvExpr::typesCompatible( existing->base, added->base, SymbolTable{} ) ) {
-                                SemanticError( added->location, "redeclaration of " + added->name );
-                        }
-                }
-                // does not need to be added to the table if both existing and added have a base that are
-                // the same
+bool SymbolTable::addedTypeConflicts(
+                const NamedTypeDecl * existing, const NamedTypeDecl * added ) const {
+        if ( existing->base == nullptr ) {
+                return false;
+        } else if ( added->base == nullptr ) {
                 return true;
-        }
-
-        /// true if redeclaration conflict between two aggregate declarations
-        bool addedDeclConflicts( const AggregateDecl * existing, const AggregateDecl * added ) {
-                if ( ! existing->body ) {
-                        return false;
-                } else if ( added->body ) {
-                        SemanticError( added, "redeclaration of " );
-                }
-                return true;
-        }
+        } else {
+                // typedef redeclarations are errors only if types are different
+                if ( ! ResolvExpr::typesCompatible( existing->base, added->base ) ) {
+                        OnFindError( added->location, "redeclaration of " + added->name );
+                }
+        }
+        // does not need to be added to the table if both existing and added have a base that are
+        // the same
+        return true;
+}
+
+bool SymbolTable::addedDeclConflicts( 
+                const AggregateDecl * existing, const AggregateDecl * added ) const {
+        if ( ! existing->body ) {
+                return false;
+        } else if ( added->body ) {
+                OnFindError( added, "redeclaration of " );
+        }
+        return true;
 }
 
@@ -642 +649 @@
         } 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
                 if ( deleter && ! existing.deleter ) {
                         if ( handleConflicts.mode == OnConflict::Error ) {
-                                SemanticError( added, "deletion of defined identifier " );
+                                OnFindError( added, "deletion of defined identifier " );
                         }
                         return true;
                 } else if ( ! deleter && existing.deleter ) {
                         if ( handleConflicts.mode == OnConflict::Error ) {
-                                SemanticError( added, "definition of deleted identifier " );
+                                OnFindError( added, "definition of deleted identifier " );
                         }
                         return true;
@@ -660 +667 @@
                 if ( isDefinition( added ) && isDefinition( existing.id ) ) {
                         if ( handleConflicts.mode == OnConflict::Error ) {
-                                SemanticError( added,
+                                OnFindError( added,
                                         isFunction( added ) ?
                                                 "duplicate function definition for " :
@@ -669 +676 @@
         } else {
                 if ( handleConflicts.mode == OnConflict::Error ) {
-                        SemanticError( added, "duplicate definition for " );
+                        OnFindError( added, "duplicate definition for " );
                 }
                 return true;
@@ -721 +728 @@
                 // Check that a Cforall declaration doesn't override any C declaration
                 if ( hasCompatibleCDecl( name, mangleName ) ) {
-                        SemanticError( decl, "Cforall declaration hides C function " );
+                        OnFindError( decl, "Cforall declaration hides C function " );
                 }
         } else {
@@ -727 +734 @@
                 // type-compatibility, which it may not be.
                 if ( hasIncompatibleCDecl( name, mangleName ) ) {
-                        SemanticError( decl, "conflicting overload of C function " );
+                        OnFindError( decl, "conflicting overload of C function " );
                 }
         }

src/AST/SymbolTable.hpp

@@ -93 +93 @@
 
 public:
-        SymbolTable();
+
+        /// Mode to control when (during which pass) user-caused name-declaration errors get reported.
+        /// The default setting `AssertClean` supports, "I expect all user-caused errors to have been
+        /// reported by now," or, "I wouldn't know what to do with an error; are there even any here?"
+        enum ErrorDetection {
+                AssertClean,               ///< invalid user decls => assert fails during addFoo (default)
+                ValidateOnAdd,             ///< invalid user decls => calls SemanticError during addFoo
+                IgnoreErrors               ///< acts as if unspecified decls were removed, forcing validity
+        };
+
+        explicit SymbolTable(
+                ErrorDetection             ///< mode for the lifetime of the symbol table (whole pass)
+        );
+        SymbolTable() : SymbolTable(AssertClean) {}
         ~SymbolTable();
+
+        ErrorDetection getErrorMode() const {
+                return errorMode;
+        }
 
         // when using an indexer manually (e.g., within a mutator traversal), it is necessary to
@@ -158 +175 @@
 
 private:
+        void OnFindError( CodeLocation location, std::string error ) const;
+
+        template< typename T >
+        void OnFindError( const T * obj, const std::string & error ) const {
+                OnFindError( obj->location, toString( error, obj ) );
+        }
+
+        template< typename T >
+        void OnFindError( CodeLocation location, const T * obj, const std::string & error ) const {
+                OnFindError( location, toString( error, obj ) );
+        }
+
         /// Ensures that a proper backtracking scope exists before a mutation
         void lazyInitScope();
@@ -168 +197 @@
         bool removeSpecialOverrides( IdData & decl, MangleTable::Ptr & mangleTable );
 
-        /// Options for handling identifier conflicts
+        /// Error detection mode given at construction (pass-specific).
+        /// Logically const, except that the symbol table's push-pop is achieved by autogenerated
+        /// assignment onto self.  The feield is left motuable to keep this code-gen simple.
+        /// Conceptual constness is preserved by all SymbolTable in a stack sharing the same mode.
+        ErrorDetection errorMode;
+
+        /// Options for handling identifier conflicts.
+        /// Varies according to AST location during traversal: captures semantics of the construct
+        /// being visited as "would shadow" vs "must not collide."
+        /// At a given AST location, is the same for every pass.
         struct OnConflict {
                 enum {
-                        Error,  ///< Throw a semantic error
+                        Error,  ///< Follow the current pass's ErrorDetection mode (may throw a semantic error)
                         Delete  ///< Delete the earlier version with the delete statement
                 } mode;
@@ -191 +229 @@
                 const Decl * deleter );
 
+        /// true if redeclaration conflict between two types
+        bool addedTypeConflicts( const NamedTypeDecl * existing, const NamedTypeDecl * added ) const;
+
+        /// true if redeclaration conflict between two aggregate declarations
+        bool addedDeclConflicts( const AggregateDecl * existing, const AggregateDecl * added ) const;
+
         /// common code for addId, addDeletedId, etc.
         void addIdCommon(
@@ -213 +257 @@
 }
 
+
 // Local Variables: //
 // tab-width: 4 //

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

@@ -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/Util.cpp

@@ -83 +83 @@
 }
 
+/// Check that the MemberExpr has an aggregate type and matching member.
+void memberMatchesAggregate( const MemberExpr * expr ) {
+        const Type * aggrType = expr->aggregate->result->stripReferences();
+        const AggregateDecl * decl = nullptr;
+        if ( auto inst = dynamic_cast<const StructInstType *>( aggrType ) ) {
+                decl = inst->base;
+        } else if ( auto inst = dynamic_cast<const UnionInstType *>( aggrType ) ) {
+                decl = inst->base;
+        }
+        assertf( decl, "Aggregate of member not correct type." );
+
+        for ( auto aggrMember : decl->members ) {
+                if ( expr->member == aggrMember ) {
+                        return;
+                }
+        }
+        assertf( false, "Member not found." );
+}
+
 struct InvariantCore {
         // To save on the number of visits: this is a kind of composed core.
@@ -108 +127 @@
         }
 
+        void previsit( const MemberExpr * node ) {
+                previsit( (const ParseNode *)node );
+                memberMatchesAggregate( node );
+        }
+
         void postvisit( const Node * node ) {
                 no_strong_cycles.postvisit( node );

src/Concurrency/Actors.cpp

@@ -38 +38 @@
     bool namedDecl = false;
 
-    // finds and sets a ptr to the Allocation enum, which is needed in the next pass
+    // finds and sets a ptr to the allocation enum, which is needed in the next pass
     void previsit( const EnumDecl * decl ) {
-        if( decl->name == "Allocation" ) *allocationDecl = decl;
+        if( decl->name == "allocation" ) *allocationDecl = decl;
     }
 
@@ -227 +227 @@
                 static inline derived_actor & ?|?( derived_actor & receiver, derived_msg & msg ) {
                     request new_req;
-                    Allocation (*my_work_fn)( derived_actor &, derived_msg & ) = receive;
+                    allocation (*my_work_fn)( derived_actor &, derived_msg & ) = receive;
                     __receive_fn fn = (__receive_fn)my_work_fn;
                     new_req{ &receiver, &msg, fn };
@@ -246 +246 @@
             ));
             
-            // Function type is: Allocation (*)( derived_actor &, derived_msg & )
+            // Function type is: allocation (*)( derived_actor &, derived_msg & )
             FunctionType * derivedReceive = new FunctionType();
             derivedReceive->params.push_back( ast::deepCopy( derivedActorRef ) );
@@ -252 +252 @@
             derivedReceive->returns.push_back( new EnumInstType( *allocationDecl ) );
 
-            // Generates: Allocation (*my_work_fn)( derived_actor &, derived_msg & ) = receive;
+            // Generates: allocation (*my_work_fn)( derived_actor &, derived_msg & ) = receive;
             sendBody->push_back( new DeclStmt(
                 decl->location,
@@ -263 +263 @@
             ));
 
-            // Function type is: Allocation (*)( actor &, message & )
+            // Function type is: allocation (*)( actor &, message & )
             FunctionType * genericReceive = new FunctionType();
             genericReceive->params.push_back( new ReferenceType( new StructInstType( *actorDecl ) ) );
@@ -269 +269 @@
             genericReceive->returns.push_back( new EnumInstType( *allocationDecl ) );
 
-            // Generates: Allocation (*fn)( actor &, message & ) = (Allocation (*)( actor &, message & ))my_work_fn;
+            // Generates: allocation (*fn)( actor &, message & ) = (allocation (*)( actor &, message & ))my_work_fn;
             // More readable synonymous code: 
-            //     typedef Allocation (*__receive_fn)(actor &, message &);
+            //     typedef allocation (*__receive_fn)(actor &, message &);
             //     __receive_fn fn = (__receive_fn)my_work_fn;
             sendBody->push_back( new DeclStmt(
@@ -422 +422 @@
     const StructDecl ** msgDecl = &msgDeclPtr;
 
-    // first pass collects ptrs to Allocation enum, request type, and generic receive fn typedef
+    // first pass collects ptrs to allocation enum, request type, and generic receive fn typedef
     // also populates maps of all derived actors and messages
     Pass<CollectactorStructDecls>::run( translationUnit, actorStructDecls, messageStructDecls, requestDecl, 

src/Concurrency/Waituntil.cpp

@@ -14 +14 @@
 //
 
+#include "Waituntil.hpp"
+
 #include <string>
 
-#include "Waituntil.hpp"
+#include "AST/Copy.hpp"
 #include "AST/Expr.hpp"
 #include "AST/Pass.hpp"
@@ -93 +95 @@
                         case 0:
                             try {
-                                if (on_selected( A, clause1 ))
+                                    on_selected( A, clause1 );
                                     doA();
                             }
@@ -120 +122 @@
         // the unregister and on_selected calls are needed to support primitives where the acquire has side effects
         // so the corresponding block MUST be run for those primitives to not lose state (example is channels)
-        if ( ! has_run(clause_statuses[0]) && whenA && unregister_select(A, clause1) && on_selected( A, clause1 ) )
+        if ( !has_run(clause_statuses[0]) && whenA && unregister_select(A, clause1) )
+            on_selected( A, clause1 )
             doA(); 
         ... repeat if above for B and C ...
@@ -617 +620 @@
 
 // Generates:
-/* if ( on_selected( target_1, node_1 )) ... corresponding body of target_1 ... 
+/* on_selected( target_1, node_1 ); ... corresponding body of target_1 ... 
 */
 CompoundStmt * GenerateWaitUntilCore::genStmtBlock( const WhenClause * clause, const ClauseData * data ) {
@@ -623 +626 @@
     return new CompoundStmt( cLoc,
         {
-            new IfStmt( cLoc,
-                genSelectTraitCall( clause, data, "on_selected" ),
-                new CompoundStmt( cLoc,
-                    {
-                        ast::deepCopy( clause->stmt )
-                    }
-                )
-            )
+            new ExprStmt( cLoc,
+                genSelectTraitCall( clause, data, "on_selected" )
+            ),
+            ast::deepCopy( clause->stmt )
         }
     );
@@ -642 +641 @@
             case 0:
                 try {
-                    if (on_selected( target1, clause1 ))
-                        dotarget1stmt();
+                    on_selected( target1, clause1 );
+                    dotarget1stmt();
                 }
                 finally { clause_statuses[i] = __SELECT_RUN; unregister_select(target1, clause1); }
@@ -662 +661 @@
         case 0:
             try {
-                if (on_selected( target1, clause1 ))
-                    dotarget1stmt();
+                on_selected( target1, clause1 );
+                dotarget1stmt();
             }
             finally { clause_statuses[i] = __SELECT_RUN; unregister_select(target1, clause1); }
@@ -938 +937 @@
         }
 
-    // C_TODO: will remove this commented code later. Currently it isn't needed but may switch to a modified version of this later if it has better performance
-    // std::vector<ptr<CaseClause>> switchCases;
-
-    // int idx = 0;
-    // for ( const auto & clause: stmt->clauses ) {
-    //     const CodeLocation & cLoc = clause->location;
-    //     switchCases.push_back(
-    //         new CaseClause( cLoc,
-    //             new CastExpr( cLoc, 
-    //                 new AddressExpr( cLoc, new NameExpr( cLoc, data.at(idx)->targetName ) ),
-    //                 new BasicType( BasicType::Kind::LongUnsignedInt ), GeneratedFlag::ExplicitCast 
-    //             ),
-    //             {
-    //                 new CompoundStmt( cLoc,
-    //                     {
-    //                         ast::deepCopy( clause->stmt ),
-    //                         new BranchStmt( cLoc, BranchStmt::Kind::Break, Label( cLoc ) )
-    //                     }
-    //                 )
-    //             }
-    //         )
-    //     );
-    //     idx++;
-    // }
-
     return new CompoundStmt( loc,
         {
             new ExprStmt( loc, new UntypedExpr( loc, new NameExpr( loc, "park" ) ) ),
             outerIf
-            // new SwitchStmt( loc,
-            //     new NameExpr( loc, statusName ),
-            //     std::move( switchCases )
-            // )
         }
     );
@@ -1013 +983 @@
     const CodeLocation & cLoc = stmt->clauses.at(idx)->location;
 
+    Expr * baseCond = genSelectTraitCall( stmt->clauses.at(idx), data.at(idx), "register_select" );
     Expr * ifCond;
 
@@ -1023 +994 @@
             ),
             new CastExpr( cLoc,
-                genSelectTraitCall( stmt->clauses.at(idx), data.at(idx), "register_select" ),
+                baseCond,
                 new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast 
             ),
             LogicalFlag::AndExpr
         );
-    } else ifCond = genSelectTraitCall( stmt->clauses.at(idx), data.at(idx), "register_select" );
+    } else ifCond = baseCond;
 
     return new CompoundStmt( cLoc,
@@ -1046 +1017 @@
                 ifCond,
                 genStmtBlock( stmt->clauses.at(idx), data.at(idx) ),
-                // ast::deepCopy( stmt->clauses.at(idx)->stmt ),
                 recursiveOrIfGen( stmt, data, idx + 1, elseWhenName )
             )

src/ControlStruct/ExceptDeclNew.cpp

@@ -18 +18 @@
 #include <sstream>
 
+#include "AST/Copy.hpp"
 #include "AST/Decl.hpp"
 #include "AST/Pass.hpp"

src/GenPoly/InstantiateGenericNew.cpp

@@ -362 +362 @@
                         ResolvExpr::typesCompatible(
                                 memberExpr->result,
-                                memberExpr->member->get_type(), ast::SymbolTable() ) ) {
+                                memberExpr->member->get_type() ) ) {
                 return memberExpr;
         }

src/GenPoly/LvalueNew.cpp

@@ -359 +359 @@
                                 !ResolvExpr::typesCompatible(
                                         srcType,
-                                        strict_dynamic_cast<ast::ReferenceType const *>( dstType )->base,
-                                        ast::SymbolTable() ) ) {
+                                        strict_dynamic_cast<ast::ReferenceType const *>( dstType )->base ) ) {
                         // Must keep cast if cast-to type is different from the actual type.
                         return ast::mutate_field( expr, &ast::CastExpr::arg, ret );
@@ -377 +376 @@
                 if ( !ResolvExpr::typesCompatibleIgnoreQualifiers(
                                 dstType->stripReferences(),
-                                srcType->stripReferences(),
-                                ast::SymbolTable() ) ) {
+                                srcType->stripReferences() ) ) {
                         return ast::mutate_field( expr, &ast::CastExpr::arg, ret );
                 }
@@ -393 +391 @@
                                 ResolvExpr::typesCompatible(
                                         expr->result,
-                                        expr->arg->result, ast::SymbolTable() ) ) {
+                                        expr->arg->result ) ) {
                         PRINT(
                                 std::cerr << "types are compatible, removing cast: " << expr << '\n';
@@ -590 +588 @@
                 ast::OpenVarSet openVars;
                 ResolvExpr::unify( ret->arg2->result, ret->arg3->result, newEnv,
-                        needAssertions, haveAssertions, openVars,
-                        ast::SymbolTable(), common );
+                        needAssertions, haveAssertions, openVars, common );
                 ret->result = common ? common : ast::deepCopy( ret->arg2->result );
                 return ret;

src/GenPoly/SpecializeNew.cpp

@@ -16 +16 @@
 #include "Specialize.h"
 
+#include "AST/Copy.hpp"                  // for deepCopy
 #include "AST/Inspect.hpp"               // for isIntrinsicCallExpr
 #include "AST/Pass.hpp"                  // for Pass

src/InitTweak/InitTweak.cc

@@ -1066 +1066 @@
         const ast::Type * t2 = ftype->params.back();
 
-        return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, ast::SymbolTable() );
+        return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2 );
 }
 

src/MakeLibCfaNew.cpp

@@ -16 +16 @@
 #include "MakeLibCfa.h"
 
+#include "AST/Copy.hpp"
 #include "AST/Fwd.hpp"
 #include "AST/Pass.hpp"

src/Parser/lex.ll

@@ -10 +10 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Tue May  2 08:45:21 2023
- * Update Count     : 769
+ * Last Modified On : Fri Jun  9 10:04:00 2023
+ * Update Count     : 770
  */
 
@@ -319 +319 @@
 static                  { KEYWORD_RETURN(STATIC); }
 _Static_assert  { KEYWORD_RETURN(STATICASSERT); }               // C11
+_static_assert  { KEYWORD_RETURN(STATICASSERT); }               // C23
 struct                  { KEYWORD_RETURN(STRUCT); }
 suspend                 { KEYWORD_RETURN(SUSPEND); }                    // CFA

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Apr 26 16:45:37 2023
-// Update Count     : 6330
+// Last Modified On : Wed Jun  7 14:32:28 2023
+// Update Count     : 6341
 //
 
@@ -108 +108 @@
         assert( declList );
         // printf( "distAttr1 typeSpec %p\n", typeSpec ); typeSpec->print( std::cout );
-        DeclarationNode * cur = declList, * cl = (new DeclarationNode)->addType( typeSpec );
+        DeclarationNode * cl = (new DeclarationNode)->addType( typeSpec );
         // printf( "distAttr2 cl %p\n", cl ); cl->type->print( std::cout );
         // cl->type->aggregate.name = cl->type->aggInst.aggregate->aggregate.name;
 
-        for ( cur = dynamic_cast<DeclarationNode *>( cur->get_next() ); cur != nullptr; cur = dynamic_cast<DeclarationNode *>( cur->get_next() ) ) {
+        for ( DeclarationNode * cur = dynamic_cast<DeclarationNode *>( declList->get_next() ); cur != nullptr; cur = dynamic_cast<DeclarationNode *>( cur->get_next() ) ) {
                 cl->cloneBaseType( cur );
         } // for
@@ -206 +206 @@
 #define NEW_ONE  new ExpressionNode( build_constantInteger( yylloc, *new string( "1" ) ) )
 #define UPDOWN( compop, left, right ) (compop == OperKinds::LThan || compop == OperKinds::LEThan ? left : right)
-#define MISSING_ANON_FIELD "Missing loop fields with an anonymous loop index is meaningless as loop index is unavailable in loop body."
-#define MISSING_LOW "Missing low value for up-to range so index is uninitialized."
-#define MISSING_HIGH "Missing high value for down-to range so index is uninitialized."
+#define MISSING_ANON_FIELD "syntax error, missing loop fields with an anonymous loop index is meaningless as loop index is unavailable in loop body."
+#define MISSING_LOW "syntax error, missing low value for up-to range so index is uninitialized."
+#define MISSING_HIGH "syntax error, missing high value for down-to range so index is uninitialized."
 
 static ForCtrl * makeForCtrl(
@@ -232 +232 @@
 ForCtrl * forCtrl( const CodeLocation & location, DeclarationNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         if ( index->initializer ) {
-                SemanticError( yylloc, "Direct initialization disallowed. Use instead: type var; initialization ~ comparison ~ increment." );
+                SemanticError( yylloc, "syntax error, direct initialization disallowed. Use instead: type var; initialization ~ comparison ~ increment." );
         } // if
         if ( index->next ) {
-                SemanticError( yylloc, "Multiple loop indexes disallowed in for-loop declaration." );
+                SemanticError( yylloc, "syntax error, multiple loop indexes disallowed in for-loop declaration." );
         } // if
         DeclarationNode * initDecl = index->addInitializer( new InitializerNode( start ) );
@@ -260 +260 @@
                         return forCtrl( location, type, new string( identifier->name ), start, compop, comp, inc );
                 } else {
-                        SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed." ); return nullptr;
+                        SemanticError( yylloc, "syntax error, loop-index name missing. Expression disallowed." ); return nullptr;
                 } // if
         } else {
-                SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed." ); return nullptr;
+                SemanticError( yylloc, "syntax error, loop-index name missing. Expression disallowed. ." ); return nullptr;
         } // if
 } // forCtrl
 
 static void IdentifierBeforeIdentifier( string & identifier1, string & identifier2, const char * kind ) {
-        SemanticError( yylloc, ::toString( "Adjacent identifiers \"", identifier1, "\" and \"", identifier2, "\" are not meaningful in a", kind, ".\n"
+        SemanticError( yylloc, ::toString( "syntax error, adjacent identifiers \"", identifier1, "\" and \"", identifier2, "\" are not meaningful in a", kind, ".\n"
                                    "Possible cause is misspelled type name or missing generic parameter." ) );
 } // IdentifierBeforeIdentifier
 
 static void IdentifierBeforeType( string & identifier, const char * kind ) {
-        SemanticError( yylloc, ::toString( "Identifier \"", identifier, "\" cannot appear before a ", kind, ".\n"
+        SemanticError( yylloc, ::toString( "syntax error, identifier \"", identifier, "\" cannot appear before a ", kind, ".\n"
                                    "Possible cause is misspelled storage/CV qualifier, misspelled typename, or missing generic parameter." ) );
 } // IdentifierBeforeType
@@ -689 +689 @@
         // | RESUME '(' comma_expression ')' compound_statement
         //      { SemanticError( yylloc, "Resume expression is currently unimplemented." ); $$ = nullptr; }
-        | IDENTIFIER IDENTIFIER                                                         // syntax error
+        | IDENTIFIER IDENTIFIER                                                         // invalid syntax rules
                 { IdentifierBeforeIdentifier( *$1.str, *$2.str, "n expression" ); $$ = nullptr; }
-        | IDENTIFIER type_qualifier                                                     // syntax error
+        | IDENTIFIER type_qualifier                                                     // invalid syntax rules
                 { IdentifierBeforeType( *$1.str, "type qualifier" ); $$ = nullptr; }
-        | IDENTIFIER storage_class                                                      // syntax error
+        | IDENTIFIER storage_class                                                      // invalid syntax rules
                 { IdentifierBeforeType( *$1.str, "storage class" ); $$ = nullptr; }
-        | IDENTIFIER basic_type_name                                            // syntax error
+        | IDENTIFIER basic_type_name                                            // invalid syntax rules
                 { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; }
-        | IDENTIFIER TYPEDEFname                                                        // syntax error
+        | IDENTIFIER TYPEDEFname                                                        // invalid syntax rules
                 { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; }
-        | IDENTIFIER TYPEGENname                                                        // syntax error
+        | IDENTIFIER TYPEGENname                                                        // invalid syntax rules
                 { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; }
         ;
@@ -1152 +1152 @@
         identifier_or_type_name ':' attribute_list_opt statement
                 { $$ = $4->add_label( yylloc, $1, $3 ); }
-        | identifier_or_type_name ':' attribute_list_opt error // syntax error
-                {
-                        SemanticError( yylloc, ::toString( "Label \"", *$1.str, "\" must be associated with a statement, "
+        | identifier_or_type_name ':' attribute_list_opt error // invalid syntax rule
+                {
+                        SemanticError( yylloc, ::toString( "syntx error, label \"", *$1.str, "\" must be associated with a statement, "
                                                                                            "where a declaration, case, or default is not a statement. "
                                                                                            "Move the label or terminate with a semi-colon." ) );
@@ -1193 +1193 @@
         | statement_list_nodecl statement
                 { assert( $1 ); $1->set_last( $2 ); $$ = $1; }
-        | statement_list_nodecl error                                           // syntax error
-                { SemanticError( yylloc, "Declarations only allowed at the start of the switch body, i.e., after the '{'." ); $$ = nullptr; }
+        | statement_list_nodecl error                                           // invalid syntax rule
+                { SemanticError( yylloc, "syntax error, declarations only allowed at the start of the switch body, i.e., after the '{'." ); $$ = nullptr; }
         ;
 
@@ -1219 +1219 @@
                         $$ = $7 ? new StatementNode( build_compound( yylloc, (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
                 }
-        | SWITCH '(' comma_expression ')' '{' error '}'         // CFA, syntax error
-                { SemanticError( yylloc, "Only declarations can appear before the list of case clauses." ); $$ = nullptr; }
+        | SWITCH '(' comma_expression ')' '{' error '}'         // CFA, invalid syntax rule error
+                { SemanticError( yylloc, "synatx error, declarations can only appear before the list of case clauses." ); $$ = nullptr; }
         | CHOOSE '(' comma_expression ')' case_clause           // CFA
                 { $$ = new StatementNode( build_switch( yylloc, false, $3, $5 ) ); }
@@ -1228 +1228 @@
                         $$ = $7 ? new StatementNode( build_compound( yylloc, (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
                 }
-        | CHOOSE '(' comma_expression ')' '{' error '}'         // CFA, syntax error
-                { SemanticError( yylloc, "Only declarations can appear before the list of case clauses." ); $$ = nullptr; }
+        | CHOOSE '(' comma_expression ')' '{' error '}'         // CFA, invalid syntax rule
+                { SemanticError( yylloc, "syntax error, declarations can only appear before the list of case clauses." ); $$ = nullptr; }
         ;
 
@@ -1268 +1268 @@
 
 case_label:                                                                                             // CFA
-        CASE error                                                                                      // syntax error
-                { SemanticError( yylloc, "Missing case list after case." ); $$ = nullptr; }
+        CASE error                                                                                      // invalid syntax rule
+                { SemanticError( yylloc, "syntax error, case list missing after case." ); $$ = nullptr; }
         | CASE case_value_list ':'                                      { $$ = $2; }
-        | CASE case_value_list error                                            // syntax error
-                { SemanticError( yylloc, "Missing colon after case list." ); $$ = nullptr; }
+        | CASE case_value_list error                                            // invalid syntax rule
+                { SemanticError( yylloc, "syntax error, colon missing after case list." ); $$ = nullptr; }
         | DEFAULT ':'                                                           { $$ = new ClauseNode( build_default( yylloc ) ); }
                 // A semantic check is required to ensure only one default clause per switch/choose statement.
-        | DEFAULT error                                                                         //  syntax error
-                { SemanticError( yylloc, "Missing colon after default." ); $$ = nullptr; }
+        | DEFAULT error                                                                         //  invalid syntax rules
+                { SemanticError( yylloc, "syntax error, colon missing after default." ); $$ = nullptr; }
         ;
 
@@ -1405 +1405 @@
                         else { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                 }
-        | comma_expression updowneq comma_expression '~' '@' // CFA, error
+        | comma_expression updowneq comma_expression '~' '@' // CFA, invalid syntax rules
                 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
-        | '@' updowneq '@'                                                                      // CFA, error
+        | '@' updowneq '@'                                                                      // CFA, invalid syntax rules
                 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
-        | '@' updowneq comma_expression '~' '@'                         // CFA, error
+        | '@' updowneq comma_expression '~' '@'                         // CFA, invalid syntax rules
                 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
-        | comma_expression updowneq '@' '~' '@'                         // CFA, error
+        | comma_expression updowneq '@' '~' '@'                         // CFA, invalid syntax rules
                 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
-        | '@' updowneq '@' '~' '@'                                                      // CFA, error
+        | '@' updowneq '@' '~' '@'                                                      // CFA, invalid syntax rules
                 { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
 
@@ -1431 +1431 @@
                 {
                         if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
-                        else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
+                        else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "syntax error, equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( yylloc, $3, $1, $3->clone(), $4, nullptr, NEW_ONE );
                 }
-        | comma_expression ';' '@' updowneq '@'                         // CFA, error
-                { SemanticError( yylloc, "Missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
+        | comma_expression ';' '@' updowneq '@'                         // CFA, invalid syntax rules
+                { SemanticError( yylloc, "syntax error, missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
 
         | comma_expression ';' comma_expression updowneq comma_expression '~' comma_expression // CFA
                 { $$ = forCtrl( yylloc, $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), $7 ); }
-        | comma_expression ';' '@' updowneq comma_expression '~' comma_expression // CFA, error
+        | comma_expression ';' '@' updowneq comma_expression '~' comma_expression // CFA, invalid syntax rules
                 {
                         if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
@@ -1447 +1447 @@
                 {
                         if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
-                        else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
+                        else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "syntax error, equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( yylloc, $3, $1, $3->clone(), $4, nullptr, $7 );
                 }
         | comma_expression ';' comma_expression updowneq comma_expression '~' '@' // CFA
                 { $$ = forCtrl( yylloc, $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), nullptr ); }
-        | comma_expression ';' '@' updowneq comma_expression '~' '@' // CFA, error
+        | comma_expression ';' '@' updowneq comma_expression '~' '@' // CFA, invalid syntax rules
                 {
                         if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
@@ -1460 +1460 @@
                 {
                         if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
-                        else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
+                        else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "syntax error, equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( yylloc, $3, $1, $3->clone(), $4, nullptr, nullptr );
                 }
         | comma_expression ';' '@' updowneq '@' '~' '@' // CFA
-                { SemanticError( yylloc, "Missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
+                { SemanticError( yylloc, "syntax error, missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
 
         | declaration comma_expression                                          // CFA
@@ -1481 +1481 @@
                 {
                         if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
-                        else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
+                        else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "syntax error, equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( yylloc, $1, $2, $3, nullptr, NEW_ONE );
                 }
@@ -1495 +1495 @@
                 {
                         if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
-                        else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
+                        else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "syntax error, equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( yylloc, $1, $2, $3, nullptr, $6 );
                 }
@@ -1508 +1508 @@
                 {
                         if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
-                        else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
+                        else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "syntax error, equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( yylloc, $1, $2, $3, nullptr, nullptr );
                 }
-        | declaration '@' updowneq '@' '~' '@'                          // CFA, error
-                { SemanticError( yylloc, "Missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
+        | declaration '@' updowneq '@' '~' '@'                          // CFA, invalid syntax rules
+                { SemanticError( yylloc, "syntax error, missing low/high value for up/down-to range so index is uninitialized." ); $$ = nullptr; }
 
         | comma_expression ';' TYPEDEFname                                      // CFA, array type
@@ -1521 +1521 @@
         | comma_expression ';' downupdowneq TYPEDEFname         // CFA, array type
                 {
-                        if ( $3 == OperKinds::LEThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, "All enumation ranges are equal (all values). Remove \"=~\"." ); $$ = nullptr; }
+                        if ( $3 == OperKinds::LEThan || $3 == OperKinds::GEThan ) {
+                                SemanticError( yylloc, "syntax error, all enumeration ranges are equal (all values). Remove \"=~\"." ); $$ = nullptr;
+                        }
                         SemanticError( yylloc, "Type iterator is currently unimplemented." ); $$ = nullptr;
                 }
@@ -1616 +1618 @@
         MUTEX '(' argument_expression_list_opt ')' statement
                 {
-                        if ( ! $3 ) { SemanticError( yylloc, "mutex argument list cannot be empty." ); $$ = nullptr; }
+                        if ( ! $3 ) { SemanticError( yylloc, "syntax error, mutex argument list cannot be empty." ); $$ = nullptr; }
                         $$ = new StatementNode( build_mutex( yylloc, $3, $5 ) );
                 }
@@ -1664 +1666 @@
                 { $$ = build_waitfor_timeout( yylloc, $1, $3, $4, maybe_build_compound( yylloc, $5 ) ); }
         // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
-        | wor_waitfor_clause wor when_clause_opt timeout statement wor ELSE statement // syntax error
-                { SemanticError( yylloc, "else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
+        | wor_waitfor_clause wor when_clause_opt timeout statement wor ELSE statement // invalid syntax rules
+                { SemanticError( yylloc, "syntax error, else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
         | wor_waitfor_clause wor when_clause_opt timeout statement wor when_clause ELSE statement
                 { $$ = build_waitfor_else( yylloc, build_waitfor_timeout( yylloc, $1, $3, $4, maybe_build_compound( yylloc, $5 ) ), $7, maybe_build_compound( yylloc, $9 ) ); }
@@ -1709 +1711 @@
                 { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1, build_waituntil_timeout( yylloc, $3, $4, maybe_build_compound( yylloc, $5 ) ) ); }
         // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
-        | wor_waituntil_clause wor when_clause_opt timeout statement wor ELSE statement // syntax error
-                { SemanticError( yylloc, "else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
+        | wor_waituntil_clause wor when_clause_opt timeout statement wor ELSE statement // invalid syntax rules
+                { SemanticError( yylloc, "syntax error, else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
         | wor_waituntil_clause wor when_clause_opt timeout statement wor when_clause ELSE statement
                 { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1,
@@ -2065 +2067 @@
                         assert( $1->type );
                         if ( $1->type->qualifiers.any() ) {                     // CV qualifiers ?
-                                SemanticError( yylloc, "Useless type qualifier(s) in empty declaration." ); $$ = nullptr;
+                                SemanticError( yylloc, "syntax error, useless type qualifier(s) in empty declaration." ); $$ = nullptr;
                         }
                         // enums are never empty declarations because there must have at least one enumeration.
                         if ( $1->type->kind == TypeData::AggregateInst && $1->storageClasses.any() ) { // storage class ?
-                                SemanticError( yylloc, "Useless storage qualifier(s) in empty aggregate declaration." ); $$ = nullptr;
+                                SemanticError( yylloc, "syntax error, useless storage qualifier(s) in empty aggregate declaration." ); $$ = nullptr;
                         }
                 }
@@ -2100 +2102 @@
         | type_declaration_specifier
         | sue_declaration_specifier
-        | sue_declaration_specifier invalid_types
-                {
-                        SemanticError( yylloc, ::toString( "Missing ';' after end of ",
+        | sue_declaration_specifier invalid_types                       // invalid syntax rule
+                {
+                        SemanticError( yylloc, ::toString( "syntax error, expecting ';' at end of ",
                                 $1->type->enumeration.name ? "enum" : ast::AggregateDecl::aggrString( $1->type->aggregate.kind ),
-                                " declaration" ) );
+                                " declaration." ) );
                         $$ = nullptr;
                 }
@@ -2584 +2586 @@
                         // } // for
                 }
+        | type_specifier field_declaring_list_opt '}'           // invalid syntax rule
+                {
+                        SemanticError( yylloc, ::toString( "syntax error, expecting ';' at end of previous declaration." ) );
+                        $$ = nullptr;
+                }
         | EXTENSION type_specifier field_declaring_list_opt ';' // GCC
                 { $$ = fieldDecl( $2, $3 ); distExt( $$ ); }
@@ -2682 +2689 @@
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
                 {
-                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.any() )
-                        { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
-
+                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.any() ) {
+                                SemanticError( yylloc, "syntax error, storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." );
+                        }
                         $$ = DeclarationNode::newEnum( nullptr, $7, true, true, $3 )->addQualifiers( $5 );
                 }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
                 {
-                        if ( $3->storageClasses.any() || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
+                        if ( $3->storageClasses.any() || $3->type->qualifiers.val != 0 ) {
+                                SemanticError( yylloc, "syntax error, storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." );
+                        }
                         typedefTable.makeTypedef( *$6 );
                 }
@@ -3154 +3163 @@
         | IDENTIFIER IDENTIFIER
                 { IdentifierBeforeIdentifier( *$1.str, *$2.str, " declaration" ); $$ = nullptr; }
-        | IDENTIFIER type_qualifier                                                     // syntax error
+        | IDENTIFIER type_qualifier                                                     // invalid syntax rules
                 { IdentifierBeforeType( *$1.str, "type qualifier" ); $$ = nullptr; }
-        | IDENTIFIER storage_class                                                      // syntax error
+        | IDENTIFIER storage_class                                                      // invalid syntax rules
                 { IdentifierBeforeType( *$1.str, "storage class" ); $$ = nullptr; }
-        | IDENTIFIER basic_type_name                                            // syntax error
+        | IDENTIFIER basic_type_name                                            // invalid syntax rules
                 { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; }
-        | IDENTIFIER TYPEDEFname                                                        // syntax error
+        | IDENTIFIER TYPEDEFname                                                        // invalid syntax rules
                 { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; }
-        | IDENTIFIER TYPEGENname                                                        // syntax error
+        | IDENTIFIER TYPEGENname                                                        // invalid syntax rules
                 { IdentifierBeforeType( *$1.str, "type" ); $$ = nullptr; }
         | external_function_definition
@@ -3197 +3206 @@
         | type_qualifier_list
                 {
-                        if ( $1->type->qualifiers.any() ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
+                        if ( $1->type->qualifiers.any() ) {
+                                SemanticError( yylloc, "syntax error, CV qualifiers cannot be distributed; only storage-class and forall qualifiers." );
+                        }
                         if ( $1->type->forall ) forall = true;          // remember generic type
                 }
@@ -3208 +3219 @@
         | declaration_qualifier_list
                 {
-                        if ( $1->type && $1->type->qualifiers.any() ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
+                        if ( $1->type && $1->type->qualifiers.any() ) {
+                                SemanticError( yylloc, "syntax error, CV qualifiers cannot be distributed; only storage-class and forall qualifiers." );
+                        }
                         if ( $1->type && $1->type->forall ) forall = true; // remember generic type
                 }
@@ -3219 +3232 @@
         | declaration_qualifier_list type_qualifier_list
                 {
-                        if ( ($1->type && $1->type->qualifiers.any()) || ($2->type && $2->type->qualifiers.any()) ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
+                        if ( ($1->type && $1->type->qualifiers.any()) || ($2->type && $2->type->qualifiers.any()) ) {
+                                SemanticError( yylloc, "syntax error, CV qualifiers cannot be distributed; only storage-class and forall qualifiers." );
+                        }
                         if ( ($1->type && $1->type->forall) || ($2->type && $2->type->forall) ) forall = true; // remember generic type
                 }
@@ -3250 +3265 @@
                         $$ = $3; forall = false;
                         if ( $5 ) {
-                                SemanticError( yylloc, "Attributes cannot be associated with function body. Move attribute(s) before \"with\" clause." );
+                                SemanticError( yylloc, "syntax error, attributes cannot be associated with function body. Move attribute(s) before \"with\" clause." );
                                 $$ = nullptr;
                         } // if

src/ResolvExpr/CandidateFinder.cpp

@@ -373 +373 @@
                                                         unify(
                                                                 ttype, argType, newResult.env, newResult.need, newResult.have,
-                                                                newResult.open, symtab )
+                                                                newResult.open )
                                                 ) {
                                                         finalResults.emplace_back( std::move( newResult ) );
@@ -444 +444 @@
                                 )
 
-                                if ( unify( paramType, argType, env, need, have, open, symtab ) ) {
+                                if ( unify( paramType, argType, env, need, have, open ) ) {
                                         unsigned nextExpl = results[i].nextExpl + 1;
                                         if ( nextExpl == expl.exprs.size() ) { nextExpl = 0; }
@@ -463 +463 @@
                                         ast::OpenVarSet open = results[i].open;
 
-                                        if ( unify( paramType, cnst->result, env, need, have, open, symtab ) ) {
+                                        if ( unify( paramType, cnst->result, env, need, have, open ) ) {
                                                 results.emplace_back(
                                                         i, new ast::DefaultArgExpr{ cnst->location, cnst }, std::move( env ),
@@ -506 +506 @@
 
                                 // attempt to unify types
-                                if ( unify( paramType, argType, env, need, have, open, symtab ) ) {
+                                if ( unify( paramType, argType, env, need, have, open ) ) {
                                         // add new result
                                         results.emplace_back(
@@ -750 +750 @@
                         const ast::Type * returnType = funcType->returns.front();
                         if ( ! unify(
-                                returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab )
+                                returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen )
                         ) {
                                 // unification failed, do not pursue this candidate
@@ -1159 +1159 @@
 
                         // unification run for side-effects
-                        unify( toType, cand->expr->result, cand->env, need, have, open, symtab );
+                        unify( toType, cand->expr->result, cand->env, need, have, open );
                         Cost thisCost =
                                 (castExpr->isGenerated == ast::GeneratedFlag::GeneratedCast)
@@ -1483 +1483 @@
                                         if (
                                                 unify(
-                                                        r2->expr->result, r3->expr->result, env, need, have, open, symtab,
+                                                        r2->expr->result, r3->expr->result, env, need, have, open,
                                                         common )
                                         ) {
@@ -1556 +1556 @@
                                 if (
                                         unify(
-                                                r1->expr->result, r2->expr->result, env, need, have, open, symtab,
+                                                r1->expr->result, r2->expr->result, env, need, have, open,
                                                 common )
                                 ) {
@@ -1659 +1659 @@
 
                                 // unification run for side-effects
-                                bool canUnify = unify( toType, cand->expr->result, env, need, have, open, symtab );
+                                bool canUnify = unify( toType, cand->expr->result, env, need, have, open );
                                 (void) canUnify;
                                 Cost thisCost = computeConversionCost( cand->expr->result, toType, cand->expr->get_lvalue(),

src/ResolvExpr/CastCost.cc

@@ -165 +165 @@
                                 if (
                                         pointerType->qualifiers <= ptr->qualifiers
-                                        && typesCompatibleIgnoreQualifiers( pointerType->base, ptr->base, symtab, env )
+                                        && typesCompatibleIgnoreQualifiers( pointerType->base, ptr->base, env )
                                 ) {
                                         cost = Cost::safe;
@@ -232 +232 @@
         )
 
-        if ( typesCompatibleIgnoreQualifiers( src, dst, symtab, env ) ) {
+        if ( typesCompatibleIgnoreQualifiers( src, dst, env ) ) {
                 PRINT( std::cerr << "compatible!" << std::endl; )
                 return Cost::zero;

src/ResolvExpr/CommonType.cc

@@ -21 +21 @@
 
 #include "AST/Decl.hpp"
+#include "AST/Pass.hpp"
 #include "AST/Type.hpp"
 #include "Common/PassVisitor.h"
@@ -675 +676 @@
                 const ast::Type * type2;
                 WidenMode widen;
-                const ast::SymbolTable & symtab;
                 ast::TypeEnvironment & tenv;
                 const ast::OpenVarSet & open;
@@ -685 +685 @@
 
                 CommonType_new(
-                        const ast::Type * t2, WidenMode w, const ast::SymbolTable & st,
+                        const ast::Type * t2, WidenMode w,
                         ast::TypeEnvironment & env, const ast::OpenVarSet & o,
                         ast::AssertionSet & need, ast::AssertionSet & have )
-                : type2( t2 ), widen( w ), symtab( st ), tenv( env ), open( o ), need (need), have (have) ,result() {}
+                : type2( t2 ), widen( w ), tenv( env ), open( o ), need (need), have (have) ,result() {}
 
                 void previsit( const ast::Node * ) { visit_children = false; }
@@ -748 +748 @@
                                         ast::AssertionSet need, have;
                                         if ( ! tenv.bindVar(
-                                                var, voidPtr->base, entry->second, need, have, open, widen, symtab )
+                                                var, voidPtr->base, entry->second, need, have, open, widen )
                                         ) return;
                                 }
@@ -761 +761 @@
                                 ast::OpenVarSet newOpen{ open };
                                 if (enumInst->base->base 
-                                && unifyExact(type1, enumInst->base->base, tenv, need, have, newOpen, widen, symtab)) {
+                                && unifyExact(type1, enumInst->base->base, tenv, need, have, newOpen, widen)) {
                                         result = type1;
                                         return true;
@@ -798 +798 @@
 
                                         ast::OpenVarSet newOpen{ open };
-                                        if ( unifyExact( t1, t2, tenv, have, need, newOpen, noWiden(), symtab ) ) {
+                                        if ( unifyExact( t1, t2, tenv, have, need, newOpen, noWiden() ) ) {
                                                 result = pointer;
                                                 if ( q1.val != q2.val ) {
@@ -841 +841 @@
                                                                 if (unifyExact(
                                                                         arg1, tupleFromTypes( crnt2, end2 ), tenv, need, have, open,
-                                                                        noWiden(), symtab )) {
+                                                                        noWiden() )) {
                                                                                 break;
 
@@ -850 +850 @@
                                                                 if (unifyExact(
                                                                         tupleFromTypes( crnt1, end1 ), arg2, tenv, need, have, open,
-                                                                        noWiden(), symtab )) {
+                                                                        noWiden() )) {
                                                                                 break;
 
@@ -874 +874 @@
 
                                                                                 if ( ! unifyExact(
-                                                                                        base1, base2, tenv, need, have, open, noWiden(), symtab )
+                                                                                        base1, base2, tenv, need, have, open, noWiden() )
                                                                                 ) return;
                                                                         }       
@@ -894 +894 @@
 
                                                                                 if ( ! unifyExact(
-                                                                                        base1, base2, tenv, need, have, open, noWiden(), symtab )
+                                                                                        base1, base2, tenv, need, have, open, noWiden() )
                                                                                 ) return;
                                                                         }       
@@ -902 +902 @@
                                                         }
                                                         else if (! unifyExact(
-                                                                arg1, arg2, tenv, need, have, open, noWiden(), symtab )) return;
+                                                                arg1, arg2, tenv, need, have, open, noWiden() )) return;
 
                                                         ++crnt1; ++crnt2;
@@ -912 +912 @@
                                                         if (! unifyExact(
                                                                 t1, tupleFromTypes( crnt2, end2 ), tenv, need, have, open,
-                                                                noWiden(), symtab )) return;
+                                                                noWiden() )) return;
                                                 } else if ( crnt2 != end2 ) {
                                                         // try unifying empty tuple with ttype
@@ -919 +919 @@
                                                         if (! unifyExact(
                                                                 tupleFromTypes( crnt1, end1 ), t2, tenv, need, have, open,
-                                                                noWiden(), symtab )) return;
+                                                                noWiden() )) return;
                                                 }
                                                 if ((f1->returns.size() == 0 && f2->returns.size() == 0)
-                                                  || (f1->returns.size() == 1 && f2->returns.size() == 1 && unifyExact(f1->returns[0], f2->returns[0], tenv, need, have, open, noWiden(), symtab))) {
+                                                  || (f1->returns.size() == 1 && f2->returns.size() == 1 && unifyExact(f1->returns[0], f2->returns[0], tenv, need, have, open, noWiden()))) {
                                                         result = pointer;
 
@@ -979 +979 @@
 
                                         ast::OpenVarSet newOpen{ open };
-                                        if ( unifyExact( t1, t2, tenv, have, need, newOpen, noWiden(), symtab ) ) {
+                                        if ( unifyExact( t1, t2, tenv, have, need, newOpen, noWiden() ) ) {
                                                 result = ref;
                                                 if ( q1.val != q2.val ) {
@@ -994 +994 @@
                         } else {
                                 if (!dynamic_cast<const ast::EnumInstType *>(type2))
-                                        result = commonType( type2, ref, tenv, need, have, open, widen, symtab );
+                                        result = commonType( type2, ref, tenv, need, have, open, widen );
                         }
                 }
@@ -1012 +1012 @@
                 void postvisit( const ast::EnumInstType * enumInst ) {
                         if (!dynamic_cast<const ast::EnumInstType *>(type2))
-                                result = commonType( type2, enumInst, tenv, need, have, open, widen, symtab);
+                                result = commonType( type2, enumInst, tenv, need, have, open, widen);
                 }
 
                 void postvisit( const ast::TraitInstType * ) {}
 
-                void postvisit( const ast::TypeInstType * inst ) {
-                        if ( ! widen.first ) return;
-                        if ( const ast::NamedTypeDecl * nt = symtab.lookupType( inst->name ) ) {
-                                if ( const ast::Type * base =
-                                                strict_dynamic_cast< const ast::TypeDecl * >( nt )->base
-                                ) {
-                                        ast::CV::Qualifiers q1 = inst->qualifiers, q2 = type2->qualifiers;
-
-                                        // force t{1,2} to be cloned if their qualifiers must be mutated
-                                        ast::ptr< ast::Type > t1{ base }, t2{ type2 };
-                                        reset_qualifiers( t1, q1 );
-                                        reset_qualifiers( t2 );
-
-                                        ast::OpenVarSet newOpen{ open };
-                                        if ( unifyExact( t1, t2, tenv, have, need, newOpen, noWiden(), symtab ) ) {
-                                                result = type2;
-                                                reset_qualifiers( result, q1 | q2 );
-                                        } else {
-                                                tryResolveWithTypedEnum( t1 );
-                                        }
-                                }
-                        }
-                }
-
-                void postvisit( const ast::TupleType * tuple) {
+                void postvisit( const ast::TypeInstType * ) {}
+
+                void postvisit( const ast::TupleType * tuple ) {
                         tryResolveWithTypedEnum( tuple );
                 }
@@ -1102 +1080 @@
                 ast::ptr< ast::Type > handleReference(
                         const ast::ptr< ast::Type > & t1, const ast::ptr< ast::Type > & t2, WidenMode widen,
-                        const ast::SymbolTable & symtab, ast::TypeEnvironment & env,
+                        ast::TypeEnvironment & env,
                         const ast::OpenVarSet & open
                 ) {
@@ -1110 +1088 @@
 
                         // need unify to bind type variables
-                        if ( unify( t1, t2, env, have, need, newOpen, symtab, common ) ) {
+                        if ( unify( t1, t2, env, have, need, newOpen, common ) ) {
                                 ast::CV::Qualifiers q1 = t1->qualifiers, q2 = t2->qualifiers;
                                 PRINT(
@@ -1134 +1112 @@
                         const ast::ptr< ast::Type > & type1, const ast::ptr< ast::Type > & type2,
                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
-                        const ast::OpenVarSet & open, WidenMode widen, const ast::SymbolTable & symtab
+                        const ast::OpenVarSet & open, WidenMode widen
         ) {
                 unsigned depth1 = type1->referenceDepth();
@@ -1149 +1127 @@
                         if ( depth1 > depth2 ) {
                                 assert( ref1 );
-                                result = handleReference( ref1->base, type2, widen, symtab, env, open );
+                                result = handleReference( ref1->base, type2, widen, env, open );
                         } else {  // implies depth1 < depth2
                                 assert( ref2 );
-                                result = handleReference( type1, ref2->base, widen, symtab, env, open );
+                                result = handleReference( type1, ref2->base, widen, env, open );
                         }
 
@@ -1170 +1148 @@
                 }
                 // otherwise both are reference types of the same depth and this is handled by the visitor
-                ast::Pass<CommonType_new> visitor{ type2, widen, symtab, env, open, need, have };
+                ast::Pass<CommonType_new> visitor{ type2, widen, env, open, need, have };
                 type1->accept( visitor );
-                ast::ptr< ast::Type > result = visitor.core.result;
-
-                // handling for opaque type declarations (?)
-                if ( ! result && widen.second ) {
-                        if ( const ast::TypeInstType * inst = type2.as< ast::TypeInstType >() ) {
-                                if ( const ast::NamedTypeDecl * nt = symtab.lookupType( inst->name ) ) {
-                                        auto type = strict_dynamic_cast< const ast::TypeDecl * >( nt );
-                                        if ( type->base ) {
-                                                ast::CV::Qualifiers q1 = type1->qualifiers, q2 = type2->qualifiers;
-                                                ast::OpenVarSet newOpen{ open };
-
-                                                // force t{1,2} to be cloned if its qualifiers must be stripped, so that
-                                                // type1 and type->base are left unchanged; calling convention forces
-                                                // {type1,type->base}->strong_ref >= 1
-                                                ast::ptr<ast::Type> t1{ type1 }, t2{ type->base };
-                                                reset_qualifiers( t1 );
-                                                reset_qualifiers( t2, q1 );
-
-                                                if ( unifyExact( t1, t2, env, have, need, newOpen, noWiden(), symtab ) ) {
-                                                        result = t1;
-                                                        reset_qualifiers( result, q1 | q2 );
-                                                }
-                                        }
-                                }
-                        }
-                }
-
-                return result;
+                // ast::ptr< ast::Type > result = visitor.core.result;
+
+                return visitor.core.result;
         }
 

src/ResolvExpr/CommonType.hpp

@@ -36 +36 @@
         ast::TypeEnvironment & env,
         ast::AssertionSet & need, ast::AssertionSet & have,
-        const ast::OpenVarSet & open, WidenMode widen,
-        const ast::SymbolTable & symtab );
+        const ast::OpenVarSet & open, WidenMode widen);
 
 }

src/ResolvExpr/ConversionCost.cc

@@ -532 +532 @@
                 }
         }
-        if ( typesCompatibleIgnoreQualifiers( src, dst, symtab, env ) ) {
+        if ( typesCompatibleIgnoreQualifiers( src, dst, env ) ) {
                 return Cost::zero;
         } else if ( dynamic_cast< const ast::VoidType * >( dst ) ) {
@@ -566 +566 @@
                         ast::CV::Qualifiers tq2 = dstAsRef->base->qualifiers;
                         if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers(
-                                        srcAsRef->base, dstAsRef->base, symtab, env ) ) {
+                                        srcAsRef->base, dstAsRef->base, env ) ) {
                                 if ( tq1 == tq2 ) {
                                         return Cost::zero;
@@ -587 +587 @@
                 const ast::ReferenceType * dstAsRef = dynamic_cast< const ast::ReferenceType * >( dst );
                 assert( dstAsRef );
-                if ( typesCompatibleIgnoreQualifiers( src, dstAsRef->base, symtab, env ) ) {
+                if ( typesCompatibleIgnoreQualifiers( src, dstAsRef->base, env ) ) {
                         if ( srcIsLvalue ) {
                                 if ( src->qualifiers == dstAsRef->base->qualifiers ) {
@@ -653 +653 @@
                 ast::CV::Qualifiers tq2 = dstAsPtr->base->qualifiers;
                 if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers(
-                                pointerType->base, dstAsPtr->base, symtab, env ) ) {
+                                pointerType->base, dstAsPtr->base, env ) ) {
                         if ( tq1 == tq2 ) {
                                 cost = Cost::zero;

src/ResolvExpr/PolyCost.cc

@@ -15 +15 @@
 
 #include "AST/SymbolTable.hpp"
+#include "AST/Pass.hpp"
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"

src/ResolvExpr/Resolver.cc

@@ -1106 +1106 @@
 
                 /// Removes cast to type of argument (unlike StripCasts, also handles non-generated casts)
-                void removeExtraneousCast( ast::ptr<ast::Expr> & expr, const ast::SymbolTable & symtab ) {
+                void removeExtraneousCast( ast::ptr<ast::Expr> & expr ) {
                         if ( const ast::CastExpr * castExpr = expr.as< ast::CastExpr >() ) {
-                                if ( typesCompatible( castExpr->arg->result, castExpr->result, symtab ) ) {
+                                if ( typesCompatible( castExpr->arg->result, castExpr->result ) ) {
                                         // cast is to the same type as its argument, remove it
                                         swap_and_save_env( expr, castExpr->arg );
@@ -1196 +1196 @@
                 ast::ptr< ast::Expr > castExpr = new ast::CastExpr{ untyped, type };
                 ast::ptr< ast::Expr > newExpr = findSingleExpression( castExpr, context );
-                removeExtraneousCast( newExpr, context.symtab );
+                removeExtraneousCast( newExpr );
                 return newExpr;
         }
@@ -1261 +1261 @@
                 static size_t traceId;
                 Resolver_new( const ast::TranslationGlobal & global ) :
+                        ast::WithSymbolTable(ast::SymbolTable::ErrorDetection::ValidateOnAdd),
                         context{ symtab, global } {}
                 Resolver_new( const ResolveContext & context ) :
@@ -1834 +1835 @@
                                                                 if (
                                                                         ! unify(
-                                                                                arg->expr->result, *param, resultEnv, need, have, open,
-                                                                                symtab )
+                                                                                arg->expr->result, *param, resultEnv, need, have, open )
                                                                 ) {
                                                                         // Type doesn't match
@@ -2041 +2041 @@
                 const ast::Type * initContext = currentObject.getCurrentType();
 
-                removeExtraneousCast( newExpr, symtab );
+                removeExtraneousCast( newExpr );
 
                 // check if actual object's type is char[]

src/ResolvExpr/SatisfyAssertions.cpp

@@ -215 +215 @@
                         findOpenVars( adjType, newOpen, closed, newNeed, have, FirstOpen );
                         if ( allowConversion ) {
-                                if ( auto c = commonType( toType, adjType, newEnv, newNeed, have, newOpen, WidenMode {true, true}, sat.symtab ) ) {
+                                if ( auto c = commonType( toType, adjType, newEnv, newNeed, have, newOpen, WidenMode {true, true} ) ) {
                                         // set up binding slot for recursive assertions
                                         ast::UniqueId crntResnSlot = 0;
@@ -229 +229 @@
                         }
                         else {
-                                if ( unifyExact( toType, adjType, newEnv, newNeed, have, newOpen, WidenMode {true, true}, sat.symtab ) ) {
+                                if ( unifyExact( toType, adjType, newEnv, newNeed, have, newOpen, WidenMode {true, true} ) ) {
                                         // set up binding slot for recursive assertions
                                         ast::UniqueId crntResnSlot = 0;
@@ -392 +392 @@
                         mergeOpenVars( open, i.match.open );
 
-                        if ( ! env.combine( i.match.env, open, symtab ) ) return false;
+                        if ( ! env.combine( i.match.env, open ) ) return false;
 
                         crnt.emplace_back( i );

src/ResolvExpr/Unify.cc

@@ -128 +128 @@
                 const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env,
                 ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
-                WidenMode widen, const ast::SymbolTable & symtab );
+                WidenMode widen );
 
         bool typesCompatible( const Type * first, const Type * second, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
@@ -150 +150 @@
 
         bool typesCompatible(
-                        const ast::Type * first, const ast::Type * second, const ast::SymbolTable & symtab,
+                        const ast::Type * first, const ast::Type * second,
                         const ast::TypeEnvironment & env ) {
                 ast::TypeEnvironment newEnv;
@@ -163 +163 @@
                 findOpenVars( newSecond, open, closed, need, have, FirstOpen );
 
-                return unifyExact(newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
+                return unifyExact(newFirst, newSecond, newEnv, need, have, open, noWiden() );
         }
 
@@ -183 +183 @@
 
         bool typesCompatibleIgnoreQualifiers(
-                        const ast::Type * first, const ast::Type * second, const ast::SymbolTable & symtab,
+                        const ast::Type * first, const ast::Type * second,
                         const ast::TypeEnvironment & env ) {
                 ast::TypeEnvironment newEnv;
@@ -216 +216 @@
                         subFirst,
                         subSecond,
-                        newEnv, need, have, open, noWiden(), symtab );
+                        newEnv, need, have, open, noWiden() );
         }
 
@@ -786 +786 @@
                 const ast::OpenVarSet & open;
                 WidenMode widen;
-                const ast::SymbolTable & symtab;
         public:
                 static size_t traceId;
@@ -793 +792 @@
                 Unify_new(
                         const ast::Type * type2, ast::TypeEnvironment & env, ast::AssertionSet & need,
-                        ast::AssertionSet & have, const ast::OpenVarSet & open, WidenMode widen,
-                        const ast::SymbolTable & symtab )
+                        ast::AssertionSet & have, const ast::OpenVarSet & open, WidenMode widen )
                 : type2(type2), tenv(env), need(need), have(have), open(open), widen(widen),
-                  symtab(symtab), result(false) {}
+                result(false) {}
 
                 void previsit( const ast::Node * ) { visit_children = false; }
@@ -814 +812 @@
                                 result = unifyExact(
                                         pointer->base, pointer2->base, tenv, need, have, open,
-                                        noWiden(), symtab );
+                                        noWiden());
                         }
                 }
@@ -837 +835 @@
 
                         result = unifyExact(
-                                array->base, array2->base, tenv, need, have, open, noWiden(),
-                                symtab );
+                                array->base, array2->base, tenv, need, have, open, noWiden());
                 }
 
@@ -844 +841 @@
                         if ( auto ref2 = dynamic_cast< const ast::ReferenceType * >( type2 ) ) {
                                 result = unifyExact(
-                                        ref->base, ref2->base, tenv, need, have, open, noWiden(),
-                                        symtab );
+                                        ref->base, ref2->base, tenv, need, have, open, noWiden());
                         }
                 }
@@ -854 +850 @@
                 static bool unifyTypeList(
                         Iter crnt1, Iter end1, Iter crnt2, Iter end2, ast::TypeEnvironment & env,
-                        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
-                        const ast::SymbolTable & symtab
+                        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open
                 ) {
                         while ( crnt1 != end1 && crnt2 != end2 ) {
@@ -868 +863 @@
                                         return unifyExact(
                                                 t1, tupleFromTypes( crnt2, end2 ), env, need, have, open,
-                                                noWiden(), symtab );
+                                                noWiden() );
                                 } else if ( ! isTuple1 && isTuple2 ) {
                                         // combine remainder of list1, then unify
                                         return unifyExact(
                                                 tupleFromTypes( crnt1, end1 ), t2, env, need, have, open,
-                                                noWiden(), symtab );
+                                                noWiden() );
                                 }
 
                                 if ( ! unifyExact(
-                                        t1, t2, env, need, have, open, noWiden(), symtab )
+                                        t1, t2, env, need, have, open, noWiden() )
                                 ) return false;
 
@@ -891 +886 @@
                                 return unifyExact(
                                         t1, tupleFromTypes( crnt2, end2 ), env, need, have, open,
-                                        noWiden(), symtab );
+                                        noWiden() );
                         } else if ( crnt2 != end2 ) {
                                 // try unifying empty tuple with ttype
@@ -898 +893 @@
                                 return unifyExact(
                                         tupleFromTypes( crnt1, end1 ), t2, env, need, have, open,
-                                        noWiden(), symtab );
+                                        noWiden() );
                         }
 
@@ -908 +903 @@
                         const std::vector< ast::ptr< ast::Type > > & list2,
                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
-                        const ast::OpenVarSet & open, const ast::SymbolTable & symtab
+                        const ast::OpenVarSet & open
                 ) {
                         return unifyTypeList(
-                                list1.begin(), list1.end(), list2.begin(), list2.end(), env, need, have, open,
-                                symtab );
+                                list1.begin(), list1.end(), list2.begin(), list2.end(), env, need, have, open);
                 }
 
@@ -953 +947 @@
                         ) return;
 
-                        if ( ! unifyTypeList( params, params2, tenv, need, have, open, symtab ) ) return;
+                        if ( ! unifyTypeList( params, params2, tenv, need, have, open ) ) return;
                         if ( ! unifyTypeList(
-                                func->returns, func2->returns, tenv, need, have, open, symtab ) ) return;
+                                func->returns, func2->returns, tenv, need, have, open ) ) return;
 
                         markAssertions( have, need, func );
@@ -1026 +1020 @@
 
                                 if ( ! unifyExact(
-                                                pty, pty2, tenv, need, have, open, noWiden(), symtab ) ) {
+                                                pty, pty2, tenv, need, have, open, noWiden() ) ) {
                                         result = false;
                                         return;
@@ -1065 +1059 @@
                         const std::vector< ast::ptr< ast::Type > > & list1,
                         const std::vector< ast::ptr< ast::Type > > & list2, ast::TypeEnvironment & env,
-                        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
-                        const ast::SymbolTable & symtab
+                        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open
                 ) {
                         auto crnt1 = list1.begin();
@@ -1081 +1074 @@
                                         return unifyExact(
                                                 t1, tupleFromTypes( list2 ), env, need, have, open,
-                                                noWiden(), symtab );
+                                                noWiden() );
                                 } else if ( ! isTuple1 && isTuple2 ) {
                                         // combine entirety of list1, then unify
                                         return unifyExact(
                                                 tupleFromTypes( list1 ), t2, env, need, have, open,
-                                                noWiden(), symtab );
+                                                noWiden() );
                                 }
 
                                 if ( ! unifyExact(
-                                        t1, t2, env, need, have, open, noWiden(), symtab )
+                                        t1, t2, env, need, have, open, noWiden() )
                                 ) return false;
 
@@ -1104 +1097 @@
                                 return unifyExact(
                                                 t1, tupleFromTypes( list2 ), env, need, have, open,
-                                                noWiden(), symtab );
+                                                noWiden() );
                         } else if ( crnt2 != list2.end() ) {
                                 // try unifying empty tuple with ttype
@@ -1113 +1106 @@
                                 return unifyExact(
                                                 tupleFromTypes( list1 ), t2, env, need, have, open,
-                                                noWiden(), symtab );
+                                                noWiden() );
                         }
 
@@ -1132 +1125 @@
                         auto types2 = flatten( flat2 );
 
-                        result = unifyList( types, types2, tenv, need, have, open, symtab );
+                        result = unifyList( types, types2, tenv, need, have, open );
                 }
 
@@ -1156 +1149 @@
                         const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
-                        ast::OpenVarSet & open, const ast::SymbolTable & symtab
+                        ast::OpenVarSet & open
         ) {
                 ast::ptr<ast::Type> common;
-                return unify( type1, type2, env, need, have, open, symtab, common );
+                return unify( type1, type2, env, need, have, open, common );
         }
 
@@ -1165 +1158 @@
                         const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
-                        ast::OpenVarSet & open, const ast::SymbolTable & symtab, ast::ptr<ast::Type> & common
+                        ast::OpenVarSet & open, ast::ptr<ast::Type> & common
         ) {
                 ast::OpenVarSet closed;
@@ -1171 +1164 @@
                 findOpenVars( type2, open, closed, need, have, FirstOpen );
                 return unifyInexact(
-                        type1, type2, env, need, have, open, WidenMode{ true, true }, symtab, common );
+                        type1, type2, env, need, have, open, WidenMode{ true, true }, common );
         }
 
@@ -1177 +1170 @@
                         const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env,
                         ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
-                        WidenMode widen, const ast::SymbolTable & symtab
+                        WidenMode widen
         ) {
                 if ( type1->qualifiers != type2->qualifiers ) return false;
@@ -1193 +1186 @@
                         return env.bindVarToVar(
                                 var1, var2, ast::TypeData{ entry1->second, entry2->second }, need, have,
-                                open, widen, symtab );
+                                open, widen );
                 } else if ( isopen1 ) {
-                        return env.bindVar( var1, type2, entry1->second, need, have, open, widen, symtab );
+                        return env.bindVar( var1, type2, entry1->second, need, have, open, widen );
                 } else if ( isopen2 ) {
-                        return env.bindVar( var2, type1, entry2->second, need, have, open, widen, symtab );
+                        return env.bindVar( var2, type1, entry2->second, need, have, open, widen );
                 } else {
                         return ast::Pass<Unify_new>::read(
-                                type1, type2, env, need, have, open, widen, symtab );
+                                type1, type2, env, need, have, open, widen );
                 }
         }
@@ -1207 +1200 @@
                         const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
-                        const ast::OpenVarSet & open, WidenMode widen, const ast::SymbolTable & symtab,
+                        const ast::OpenVarSet & open, WidenMode widen,
                         ast::ptr<ast::Type> & common
         ) {
@@ -1221 +1214 @@
                 ast::ptr< ast::Type > t2_(t2);
 
-                if ( unifyExact( t1, t2, env, need, have, open, widen, symtab ) ) {
+                if ( unifyExact( t1, t2, env, need, have, open, widen ) ) {
                         // if exact unification on unqualified types, try to merge qualifiers
                         if ( q1 == q2 || ( ( q1 > q2 || widen.first ) && ( q2 > q1 || widen.second ) ) ) {
@@ -1231 +1224 @@
                         }
 
-                } else if (( common = commonType( t1, t2, env, need, have, open, widen, symtab ))) {
+                } else if (( common = commonType( t1, t2, env, need, have, open, widen ))) {
                         // no exact unification, but common type
                         auto c = shallowCopy(common.get());

src/ResolvExpr/Unify.h

@@ -59 +59 @@
         const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
-        ast::OpenVarSet & open, const ast::SymbolTable & symtab );
+        ast::OpenVarSet & open );
 
 bool unify(
         const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
-        ast::OpenVarSet & open, const ast::SymbolTable & symtab, ast::ptr<ast::Type> & common );
+        ast::OpenVarSet & open, ast::ptr<ast::Type> & common );
 
 bool unifyExact(
         const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env,
         ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
-        WidenMode widen, const ast::SymbolTable & symtab );
+        WidenMode widen );
 
 bool unifyInexact(
         const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
-        const ast::OpenVarSet & open, WidenMode widen, const ast::SymbolTable & symtab,
+        const ast::OpenVarSet & open, WidenMode widen, 
         ast::ptr<ast::Type> & common );
 
 bool typesCompatible(
-        const ast::Type *, const ast::Type *, const ast::SymbolTable & symtab = {},
+        const ast::Type *, const ast::Type *, 
         const ast::TypeEnvironment & env = {} );
 
 bool typesCompatibleIgnoreQualifiers(
-        const ast::Type *, const ast::Type *, const ast::SymbolTable & symtab = {},
+        const ast::Type *, const ast::Type *,
         const ast::TypeEnvironment & env = {} );
 

src/SymTab/Autogen.h

@@ -20 +20 @@
 #include <string>                 // for string
 
-#include "AST/Decl.hpp"
-#include "AST/Expr.hpp"
-#include "AST/Init.hpp"
-#include "AST/Node.hpp"
-#include "AST/Stmt.hpp"
-#include "AST/Type.hpp"
 #include "CodeGen/OperatorTable.h"
 #include "Common/UniqueName.h"    // for UniqueName
@@ -57 +51 @@
         /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
         FunctionType * genCopyType( Type * paramType, bool maybePolymorphic = true );
-
-        /// Enum for loop direction
-        enum LoopDirection { LoopBackward, LoopForward };
 
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.

src/SymTab/GenImplicitCall.cpp

@@ -16 +16 @@
 #include "GenImplicitCall.hpp"
 
+#include "AST/Decl.hpp"                  // for ObjectDecl
+#include "AST/Expr.hpp"                  // for ConstantExpr, UntypedExpr,...
+#include "AST/Init.hpp"                  // for SingleInit
 #include "AST/Inspect.hpp"               // for isUnnamedBitfield
+#include "AST/Stmt.hpp"                  // for ExprStmt
+#include "AST/Type.hpp"                  // for ArrayType, BasicType, ...
 #include "CodeGen/OperatorTable.h"       // for isCtorDtor
 #include "Common/UniqueName.h"           // for UniqueName
 
 namespace SymTab {
+
+namespace {
 
 template< typename OutIter >
@@ -173 +180 @@
 }
 
+} // namespace
+
 ast::ptr< ast::Stmt > genImplicitCall(
         InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,

src/SymTab/GenImplicitCall.hpp

@@ -17 +17 @@
 
 #include "InitTweak/InitTweak.h"  // for InitExpander
-#include "SymTab/Autogen.h"       // for LoopDirection
 
 namespace SymTab {
 
+/// Enum for loop direction
+enum LoopDirection { LoopBackward, LoopForward };
+
+/// Returns a generated call expression to function fname with srcParam and
+/// dstParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
 ast::ptr<ast::Stmt> genImplicitCall(
         InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
@@ -34 +38 @@
 // compile-command: "make install" //
 // End: //
-

src/Tuples/Explode.cc

@@ -17 +17 @@
 #include <list>                  // for list
 
+#include "AST/Pass.hpp"          // for Pass
 #include "SynTree/Mutator.h"     // for Mutator
 #include "Common/PassVisitor.h"  // for PassVisitor

src/Validate/Autogen.cpp

@@ -25 +25 @@
 
 #include "AST/Attribute.hpp"
+#include "AST/Copy.hpp"
 #include "AST/Create.hpp"
 #include "AST/Decl.hpp"
@@ -43 +44 @@
 #include "CompilationState.h"
 
-// TODO: The other new ast function should be moved over to this file.
-#include "SymTab/Autogen.h"
-
 namespace Validate {
 
@@ -95 +93 @@
 
         const CodeLocation& getLocation() const { return getDecl()->location; }
-        ast::FunctionDecl * genProto( const std::string& name,
+        ast::FunctionDecl * genProto( std::string&& name,
                 std::vector<ast::ptr<ast::DeclWithType>>&& params,
                 std::vector<ast::ptr<ast::DeclWithType>>&& returns ) const;
@@ -336 +334 @@
 }
 
+void replaceAll( std::vector<ast::ptr<ast::DeclWithType>> & dwts,
+                const ast::DeclReplacer::TypeMap & map ) {
+        for ( auto & dwt : dwts ) {
+                dwt = strict_dynamic_cast<const ast::DeclWithType *>(
+                                ast::DeclReplacer::replace( dwt, map ) );
+        }
+}
+
 /// Generates a basic prototype function declaration.
-ast::FunctionDecl * FuncGenerator::genProto( const std::string& name,
+ast::FunctionDecl * FuncGenerator::genProto( std::string&& name,
                 std::vector<ast::ptr<ast::DeclWithType>>&& params,
                 std::vector<ast::ptr<ast::DeclWithType>>&& returns ) const {
@@ -343 +349 @@
         // Handle generic prameters and assertions, if any.
         auto const & old_type_params = getGenericParams( type );
+        ast::DeclReplacer::TypeMap oldToNew;
         std::vector<ast::ptr<ast::TypeDecl>> type_params;
         std::vector<ast::ptr<ast::DeclWithType>> assertions;
         for ( auto & old_param : old_type_params ) {
                 ast::TypeDecl * decl = ast::deepCopy( old_param );
-                for ( auto assertion : decl->assertions ) {
-                        assertions.push_back( assertion );
-                }
-                decl->assertions.clear();
+                decl->init = nullptr;
+                splice( assertions, decl->assertions );
+                oldToNew.emplace( std::make_pair( old_param, decl ) );
                 type_params.push_back( decl );
         }
-        // TODO: The values in params and returns still may point at the old
-        // generic params, that does not appear to be an issue but perhaps it
-        // should be addressed.
+        replaceAll( params, oldToNew );
+        replaceAll( returns, oldToNew );
+        replaceAll( assertions, oldToNew );
 
         ast::FunctionDecl * decl = new ast::FunctionDecl(
                 // Auto-generated routines use the type declaration's location.
                 getLocation(),
-                name,
+                std::move( name ),
                 std::move( type_params ),
                 std::move( assertions ),

src/Validate/FixQualifiedTypes.cpp

@@ -16 +16 @@
 #include "Validate/FixQualifiedTypes.hpp"
 
+#include "AST/Copy.hpp"
 #include "AST/LinkageSpec.hpp"             // for Linkage
 #include "AST/Pass.hpp"

src/Validate/GenericParameter.cpp

@@ -16 +16 @@
 #include "GenericParameter.hpp"
 
+#include "AST/Copy.hpp"
 #include "AST/Decl.hpp"
 #include "AST/Expr.hpp"

src/Validate/HoistStruct.cpp

@@ -18 +18 @@
 #include <sstream>
 
+#include "AST/DeclReplacer.hpp"
 #include "AST/Pass.hpp"
 #include "AST/TranslationUnit.hpp"
+#include "AST/Vector.hpp"
 
 namespace Validate {
@@ -51 +53 @@
         template<typename AggrDecl>
         AggrDecl const * postAggregate( AggrDecl const * );
+        template<typename InstType>
+        InstType const * preCollectionInstType( InstType const * type );
 
         ast::AggregateDecl const * parent = nullptr;
@@ -66 +70 @@
         qualifiedName( decl, ss );
         return ss.str();
+}
+
+void extendParams( ast::vector<ast::TypeDecl> & dstParams,
+                ast::vector<ast::TypeDecl> const & srcParams ) {
+        if ( srcParams.empty() ) return;
+
+        ast::DeclReplacer::TypeMap newToOld;
+        ast::vector<ast::TypeDecl> params;
+        for ( ast::ptr<ast::TypeDecl> const & srcParam : srcParams ) {
+                ast::TypeDecl * dstParam = ast::deepCopy( srcParam.get() );
+                dstParam->init = nullptr;
+                newToOld.emplace( srcParam, dstParam );
+                for ( auto assertion : dstParam->assertions ) {
+                        assertion = ast::DeclReplacer::replace( assertion, newToOld );
+                }
+                params.emplace_back( dstParam );
+        }
+        spliceBegin( dstParams, params );
 }
 
@@ -74 +96 @@
                 mut->parent = parent;
                 mut->name = qualifiedName( mut );
-                return mut;
-        } else {
-                GuardValue( parent ) = decl;
-                return decl;
-        }
+                extendParams( mut->params, parent->params );
+                decl = mut;
+        }
+        GuardValue( parent ) = decl;
+        return decl;
 }
 
@@ -112 +134 @@
 }
 
+ast::AggregateDecl const * commonParent(
+                ast::AggregateDecl const * lhs, ast::AggregateDecl const * rhs ) {
+        for ( auto outer = lhs ; outer ; outer = outer->parent ) {
+                for ( auto inner = rhs ; inner ; inner = inner->parent ) {
+                        if ( outer == inner ) {
+                                return outer;
+                        }
+                }
+        }
+        return nullptr;
+}
+
+template<typename InstType>
+InstType const * HoistStructCore::preCollectionInstType( InstType const * type ) {
+    if ( !type->base->parent ) return type;
+    if ( type->base->params.empty() ) return type;
+
+    InstType * mut = ast::mutate( type );
+    ast::AggregateDecl const * parent =
+        commonParent( this->parent, mut->base->parent );
+    assert( parent );
+
+    std::vector<ast::ptr<ast::Expr>> args;
+    for ( const ast::ptr<ast::TypeDecl> & param : parent->params ) {
+        args.emplace_back( new ast::TypeExpr( param->location,
+            new ast::TypeInstType( param )
+        ) );
+    }
+    spliceBegin( mut->params, args );
+    return mut;
+}
+
 template<typename InstType>
 InstType const * preInstType( InstType const * type ) {
@@ -121 +175 @@
 
 ast::StructInstType const * HoistStructCore::previsit( ast::StructInstType const * type ) {
-        return preInstType( type );
+        return preInstType( preCollectionInstType( type ) );
 }
 
 ast::UnionInstType const * HoistStructCore::previsit( ast::UnionInstType const * type ) {
-        return preInstType( type );
+        return preInstType( preCollectionInstType( type ) );
 }
 

src/Validate/ReplaceTypedef.cpp

@@ -16 +16 @@
 #include "ReplaceTypedef.hpp"
 
+#include "AST/Copy.hpp"
 #include "AST/Pass.hpp"
 #include "Common/ScopedMap.h"
@@ -149 +150 @@
                 // constant/enumerator. The effort required to fix this corner case
                 // likely outweighs the utility of allowing it.
-                if ( !ResolvExpr::typesCompatible( t0, t1, ast::SymbolTable() )
+                if ( !ResolvExpr::typesCompatible( t0, t1 )
                                 || ast::Pass<VarLenChecker>::read( t0 )
                                 || ast::Pass<VarLenChecker>::read( t1 ) ) {

src/Virtual/ExpandCasts.cc

@@ -20 +20 @@
 #include <string>                  // for string, allocator, operator==, ope...
 
+#include "AST/Copy.hpp"
 #include "AST/Decl.hpp"
 #include "AST/Expr.hpp"

src/main.cc

@@ -32 +32 @@
 
 #include "AST/Convert.hpp"
+#include "AST/Pass.hpp"                     // for pass_visitor_stats
+#include "AST/TranslationUnit.hpp"          // for TranslationUnit
 #include "AST/Util.hpp"                     // for checkInvariants
 #include "CompilationState.h"