Changeset b7b3e41 for src

src/AST/Convert.cpp

-              rfa5e1aa5
+              rb7b3e41
                                 old->location,
                                 GET_ACCEPT_1(arg, Expr),
+                                old->isGenerated ? ast::GeneratedCast : ast::ExplicitCast
+                                old->isGenerated ? ast::GeneratedCast : ast::ExplicitCast,
+                                (ast::CastExpr::CastKind) old->kind
+                        )
                 );

src/AST/Decl.cpp

-              rfa5e1aa5
+              rb7b3e41
 bool EnumDecl::valueOf( const Decl * enumerator, long long& value ) const {
         if ( enumValues.empty() ) {
                 long long crntVal = 0;
+                Evaluation crntVal = {0, true, true};  // until expression is given, we know to start counting from 0
                 for ( const Decl * member : members ) {
                         const ObjectDecl* field = strict_dynamic_cast< const ObjectDecl* >( member );
                         if ( field->init ) {
                                 const SingleInit * init = strict_dynamic_cast< const SingleInit* >( field->init.get() );
                                 auto result = eval( init->value );
                                 if ( ! result.second ) {
+                                crntVal = eval( init->value );
+                                if ( ! crntVal.isEvaluableInGCC ) {
                                         SemanticError( init->location, ::toString( "Non-constexpr in initialization of "
                                                 "enumerator: ", field ) );
+                                }
-                                crntVal = result.first;
+                        }
                         if ( enumValues.count( field->name ) != 0 ) {
                                 SemanticError( location, ::toString( "Enum ", name, " has multiple members with the "   "name ", field->name ) );
+                        }
+                        enumValues[ field->name ] = crntVal;
+                        ++crntVal;
+                        if (crntVal.hasKnownValue) {
+                                enumValues[ field->name ] = crntVal.knownValue;
+                        }
+                        ++crntVal.knownValue;
+                }
+        }

src/AST/DeclReplacer.hpp

-              rfa5e1aa5
+              rb7b3e41
 #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/Expr.cpp

-              rfa5e1aa5
+              rb7b3e41
 // --- CastExpr
 CastExpr::CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g )
 : Expr( loc, new VoidType{} ), arg( a ), isGenerated( g ) {}
+CastExpr::CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g, CastKind kind )
+: Expr( loc, new VoidType{} ), arg( a ), isGenerated( g ), kind( kind ) {}
 bool CastExpr::get_lvalue() const {

src/AST/Expr.hpp

-              rfa5e1aa5
+              rb7b3e41
                 const Expr * e )
         : decl( id ), declptr( declptr ), actualType( actual ), formalType( formal ), expr( e ) {}
+        operator bool() {return declptr;}
 };
 …
         GeneratedFlag isGenerated;
+        enum CastKind {
+                Default, // C
+                Coerce, // reinterpret cast
+                Return  // overload selection
+        };
+        CastKind kind = Default;
         CastExpr( const CodeLocation & loc, const Expr * a, const Type * to,
                 GeneratedFlag g = GeneratedCast ) : Expr( loc, to ), arg( a ), isGenerated( g ) {}
+                GeneratedFlag g = GeneratedCast, CastKind kind = Default ) : Expr( loc, to ), arg( a ), isGenerated( g ), kind( kind ) {}
         /// Cast-to-void
         CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g = GeneratedCast );
+        CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g = GeneratedCast, CastKind kind = Default );
         /// Wrap a cast expression around an existing expression (always generated)

src/AST/Pass.hpp

-              rfa5e1aa5
+              rb7b3e41
 };
+/// 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

-              rfa5e1aa5
+              rb7b3e41
                 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 {
 …
                                 });
                         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;
+                }
 …
                 /// 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;
+                }
 …
                 template<typename node_t>
                 const node_t & get( const node_t & val, long) {
+                const node_t & get( const node_t & val, long ) {
                         return val;
+                }
 …
+                }
+        }
+        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;
+        }
+}
 …
         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/SymbolTable.cpp

-              rfa5e1aa5
+              rb7b3e41
 #include "Copy.hpp"
+#include <iostream>
+#include <algorithm>
 #include "Decl.hpp"
 #include "Expr.hpp"
 …
+}
 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() {
 …
                         out.push_back(decl.second);
+                }
+                // std::cerr << otypeKey << ' ' << out.size() << std::endl;
+        }
 …
+}
+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 ) ) {
+                                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;
+}
 …
                 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;
 …
                 if ( isDefinition( added ) && isDefinition( existing.id ) ) {
                         if ( handleConflicts.mode == OnConflict::Error ) {
                                 SemanticError( added,
+                                OnFindError( added,
                                         isFunction( added ) ?
                                                 "duplicate function definition for " :
 …
         } else {
                 if ( handleConflicts.mode == OnConflict::Error ) {
                         SemanticError( added, "duplicate definition for " );
+                        OnFindError( added, "duplicate definition for " );
+                }
                 return true;
 …
                 // 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 {
 …
                 // 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

-              rfa5e1aa5
+              rb7b3e41
 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
 …
 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();
 …
         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;
 …
                 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(
 …
+}
 // Local Variables: //
 // tab-width: 4 //

src/AST/Type.hpp

-              rfa5e1aa5
+              rb7b3e41
         bool operator==(const TypeEnvKey & other) const;
         bool operator<(const TypeEnvKey & other) const;
+};
+        operator bool() {return base;}
+};
 /// tuple type e.g. `[int, char]`

src/AST/TypeEnvironment.cpp

rfa5e1aa5	rb7b3e41
135	135	}
136	136	}
137		sub.normalize();
	137	// sub.normalize();
138	138	}
139	139

src/AST/TypeEnvironment.hpp

rfa5e1aa5	rb7b3e41
63	63
64	64	int cmp = d1->var->name.compare( d2->var->name );
65		return cmp < 0 \|\| ( cmp == 0 && d1->result < d2->result );
	65	return cmp > 0 \|\| ( cmp == 0 && d1->result < d2->result );
66	66	}
67	67	};

src/AST/Util.cpp

-              rfa5e1aa5
+              rb7b3e41
+}
+/// 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.
 …
+        }
+        void previsit( const MemberExpr * node ) {
+                previsit( (const ParseNode *)node );
+                memberMatchesAggregate( node );
+        }
         void postvisit( const Node * node ) {
                 no_strong_cycles.postvisit( node );

src/Common/Eval.cc

-              rfa5e1aa5
+              rb7b3e41
 // New AST
 struct EvalNew : public ast::WithShortCircuiting {
+        long long int value = 0;                                                        // compose the result of the constant expression
+        bool valid = true;                                                                      // true => constant expression and value is the result
+                                                                                                                // false => not constant expression, e.g., ++i
+        bool cfavalid = true;                                                           // true => constant expression and value computable
+                                                                                                                // false => constant expression but value not computable, e.g., sizeof(int)
+        Evaluation result = { 0, true, true };
         void previsit( const ast::Node * ) { visit_children = false; }
         void postvisit( const ast::Node * ) { cfavalid = valid = false; }
+        void postvisit( const ast::Node * ) { result.isEvaluableInGCC = result.hasKnownValue = false; }
         void postvisit( const ast::UntypedExpr * ) {
 …
         void postvisit( const ast::ConstantExpr * expr ) {      // only handle int constants
+                value = expr->intValue();
+                result.knownValue = expr->intValue();
+                result.hasKnownValue = true;
+                result.isEvaluableInGCC = true;
+        }
         void postvisit( const ast::SizeofExpr * ) {
                 // do not change valid or value => let C figure it out
                 cfavalid = false;
+                result.hasKnownValue = false;
+                result.isEvaluableInGCC = true;
+        }
         void postvisit( const ast::AlignofExpr * ) {
                 // do not change valid or value => let C figure it out
                 cfavalid = false;
+                result.hasKnownValue = false;
+                result.isEvaluableInGCC = true;
+        }
         void postvisit( const ast::OffsetofExpr * ) {
                 // do not change valid or value => let C figure it out
                 cfavalid = false;
+                result.hasKnownValue = false;
+                result.isEvaluableInGCC = true;
+        }
         void postvisit( const ast::LogicalExpr * expr ) {
                 std::pair<long long int, bool> arg1, arg2;
+                Evaluation arg1, arg2;
                 arg1 = eval( expr->arg1 );
                 valid &= arg1.second;
                 if ( ! valid ) return;
+                result.isEvaluableInGCC &= arg1.isEvaluableInGCC;
+                if ( ! result.isEvaluableInGCC ) return;
                 arg2 = eval( expr->arg2 );
+                valid &= arg2.second;
+                if ( ! valid ) return;
+                result.isEvaluableInGCC &= arg2.isEvaluableInGCC;
+                if ( ! result.isEvaluableInGCC ) return;
+                result.hasKnownValue &= arg1.hasKnownValue;
+                result.hasKnownValue &= arg2.hasKnownValue;
+                if ( ! result.hasKnownValue ) return;
                 if ( expr->isAnd ) {
                         value = arg1.first && arg2.first;
+                        result.knownValue = arg1.knownValue && arg2.knownValue;
                 } else {
                         value = arg1.first || arg2.first;
+                        result.knownValue = arg1.knownValue || arg2.knownValue;
                 } // if
+        }
         void postvisit( const ast::ConditionalExpr * expr ) {
                 std::pair<long long int, bool> arg1, arg2, arg3;
+                Evaluation arg1, arg2, arg3;
                 arg1 = eval( expr->arg1 );
                 valid &= arg1.second;
                 if ( ! valid ) return;
+                result.isEvaluableInGCC &= arg1.isEvaluableInGCC;
+                if ( ! result.isEvaluableInGCC ) return;
                 arg2 = eval( expr->arg2 );
                 valid &= arg2.second;
                 if ( ! valid ) return;
+                result.isEvaluableInGCC &= arg2.isEvaluableInGCC;
+                if ( ! result.isEvaluableInGCC ) return;
                 arg3 = eval( expr->arg3 );
+                valid &= arg3.second;
+                if ( ! valid ) return;
+                value = arg1.first ? arg2.first : arg3.first;
+                result.isEvaluableInGCC &= arg3.isEvaluableInGCC;
+                if ( ! result.isEvaluableInGCC ) return;
+                result.hasKnownValue &= arg1.hasKnownValue;
+                result.hasKnownValue &= arg2.hasKnownValue;
+                result.hasKnownValue &= arg3.hasKnownValue;
+                if ( ! result.hasKnownValue ) return;
+                result.knownValue = arg1.knownValue ? arg2.knownValue : arg3.knownValue;
+        }
         void postvisit( const ast::CastExpr * expr ) {
+                // cfa-cc generates a cast before every constant and many other places, e.g., (int)3, so the cast argument must
+                // be evaluated to get the constant value.
+                auto arg = eval(expr->arg);
+                valid = arg.second;
+                value = arg.first;
+                cfavalid = false;
+                // cfa-cc generates a cast before every constant and many other places, e.g., (int)3,
+                // so we must use the value from the cast argument, even though we lack any basis for evaluating wraparound effects, etc
+                result = eval(expr->arg);
+        }
         void postvisit( const ast::VariableExpr * expr ) {
+                result.hasKnownValue = false;
+                result.isEvaluableInGCC = false;
                 if ( const ast::EnumInstType * inst = dynamic_cast<const ast::EnumInstType *>(expr->result.get()) ) {
                         if ( const ast::EnumDecl * decl = inst->base ) {
+                                if ( decl->valueOf( expr->var, value ) ) { // value filled by valueOf
+                                        return;
+                                }
+                                result.isEvaluableInGCC = true;
+                                result.hasKnownValue = decl->valueOf( expr->var, result.knownValue ); // result.knownValue filled by valueOf
+                        }
+                }
-                valid = false;
+        }
         void postvisit( const ast::ApplicationExpr * expr ) {
                 const ast::DeclWithType * function = ast::getFunction(expr);
+                if ( ! function || function->linkage != ast::Linkage::Intrinsic ) { valid = false; return; }
+                if ( ! function || function->linkage != ast::Linkage::Intrinsic ) {
+                        result.isEvaluableInGCC = false;
+                        result.hasKnownValue = false;
+                        return;
+                }
                 const std::string & fname = function->name;
                 assertf( expr->args.size() == 1 || expr->args.size() == 2, "Intrinsic function with %zd arguments: %s", expr->args.size(), fname.c_str() );
 …
                 if ( expr->args.size() == 1 ) {
                         // pre/postfix operators ++ and -- => assignment, which is not constant
                         std::pair<long long int, bool> arg1;
+                        Evaluation arg1;
                         arg1 = eval(expr->args.front());
+                        valid &= arg1.second;
+                        if ( ! valid ) return;
+                        result.isEvaluableInGCC &= arg1.isEvaluableInGCC;
+                        if ( ! result.isEvaluableInGCC ) return;
+                        result.hasKnownValue &= arg1.hasKnownValue;
+                        if ( ! result.hasKnownValue ) return;
                         if (fname == "+?") {
                                 value = arg1.first;
+                                result.knownValue = arg1.knownValue;
                         } else if (fname == "-?") {
                                 value = -arg1.first;
+                                result.knownValue = -arg1.knownValue;
                         } else if (fname == "~?") {
                                 value = ~arg1.first;
+                                result.knownValue = ~arg1.knownValue;
                         } else if (fname == "!?") {
                                 value = ! arg1.first;
+                                result.knownValue = ! arg1.knownValue;
                         } else {
+                                valid = false;
+                                result.isEvaluableInGCC = false;
+                                result.hasKnownValue = false;
                         } // if
                 } else { // => expr->args.size() == 2
                         // infix assignment operators => assignment, which is not constant
                         std::pair<long long int, bool> arg1, arg2;
+                        Evaluation arg1, arg2;
                         arg1 = eval(expr->args.front());
                         valid &= arg1.second;
                         if ( ! valid ) return;
+                        result.isEvaluableInGCC &= arg1.isEvaluableInGCC;
+                        if ( ! result.isEvaluableInGCC ) return;
                         arg2 = eval(expr->args.back());
+                        valid &= arg2.second;
+                        if ( ! valid ) return;
+                        result.isEvaluableInGCC &= arg2.isEvaluableInGCC;
+                        if ( ! result.isEvaluableInGCC ) return;
+                        result.hasKnownValue &= arg1.hasKnownValue;
+                        result.hasKnownValue &= arg2.hasKnownValue;
+                        if ( ! result.hasKnownValue ) return;
                         if (fname == "?+?") {
                                 value = arg1.first + arg2.first;
+                                result.knownValue = arg1.knownValue + arg2.knownValue;
                         } else if (fname == "?-?") {
                                 value = arg1.first - arg2.first;
+                                result.knownValue = arg1.knownValue - arg2.knownValue;
                         } else if (fname == "?*?") {
                                 value = arg1.first * arg2.first;
+                                result.knownValue = arg1.knownValue * arg2.knownValue;
                         } else if (fname == "?/?") {
                                 if ( arg2.first ) value = arg1.first / arg2.first;
+                                if ( arg2.knownValue ) result.knownValue = arg1.knownValue / arg2.knownValue;
                         } else if (fname == "?%?") {
                                 if ( arg2.first ) value = arg1.first % arg2.first;
+                                if ( arg2.knownValue ) result.knownValue = arg1.knownValue % arg2.knownValue;
                         } else if (fname == "?<<?") {
                                 value = arg1.first << arg2.first;
+                                result.knownValue = arg1.knownValue << arg2.knownValue;
                         } else if (fname == "?>>?") {
                                 value = arg1.first >> arg2.first;
+                                result.knownValue = arg1.knownValue >> arg2.knownValue;
                         } else if (fname == "?<?") {
                                 value = arg1.first < arg2.first;
+                                result.knownValue = arg1.knownValue < arg2.knownValue;
                         } else if (fname == "?>?") {
                                 value = arg1.first > arg2.first;
+                                result.knownValue = arg1.knownValue > arg2.knownValue;
                         } else if (fname == "?<=?") {
                                 value = arg1.first <= arg2.first;
+                                result.knownValue = arg1.knownValue <= arg2.knownValue;
                         } else if (fname == "?>=?") {
                                 value = arg1.first >= arg2.first;
+                                result.knownValue = arg1.knownValue >= arg2.knownValue;
                         } else if (fname == "?==?") {
                                 value = arg1.first == arg2.first;
+                                result.knownValue = arg1.knownValue == arg2.knownValue;
                         } else if (fname == "?!=?") {
                                 value = arg1.first != arg2.first;
+                                result.knownValue = arg1.knownValue != arg2.knownValue;
                         } else if (fname == "?&?") {
                                 value = arg1.first & arg2.first;
+                                result.knownValue = arg1.knownValue & arg2.knownValue;
                         } else if (fname == "?^?") {
                                 value = arg1.first ^ arg2.first;
+                                result.knownValue = arg1.knownValue ^ arg2.knownValue;
                         } else if (fname == "?|?") {
                                 value = arg1.first | arg2.first;
+                                result.knownValue = arg1.knownValue | arg2.knownValue;
                         } else {
+                                valid = false;
+                                result.isEvaluableInGCC = false;
+                                result.hasKnownValue = false;
+                        }
                 } // if
 …
+}
+std::pair<long long int, bool> eval( const ast::Expr * expr ) {
+        ast::Pass<EvalNew> ev;
+Evaluation eval( const ast::Expr * expr ) {
         if ( expr ) {
+                expr->accept( ev );
+                return std::make_pair( ev.core.value, ev.core.valid );
+                return ast::Pass<EvalNew>::read(expr);
+                // Evaluation ret = ast::Pass<EvalNew>::read(expr);
+                // ret.knownValue = 777;
+                // return ret;
         } else {
                 return std::make_pair( 0, false );
+                return { 0, false, false };
+        }
+}

src/Common/Eval.h

-              rfa5e1aa5
+              rb7b3e41
+}
+struct Evaluation {
+        long long int knownValue;
+        bool hasKnownValue;
+        bool isEvaluableInGCC;
+};
 /// Evaluates expr as a long long int.
 /// If second is false, expr could not be evaluated.
 std::pair<long long int, bool> eval(const Expression * expr);
 std::pair<long long int, bool> eval(const ast::Expr * expr);
+Evaluation eval(const ast::Expr * expr);
 // Local Variables: //

src/Concurrency/Actors.cpp

-              rfa5e1aa5
+              rb7b3e41
     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;
+    }
 …
                 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 };
 …
             ));
             // 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 ) );
 …
             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,
 …
             ));
             // 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 ) ) );
 …
             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(
 …
             ));
             // Generates: new_req{ &receiver, &msg, fn };
+            // Generates: new_req{ &receiver, (actor *)&receiver, &msg, (message *)&msg, fn };
             sendBody->push_back( new ExprStmt(
                 decl->location,
 …
                                                 new NameExpr( decl->location, "new_req" ),
                         new AddressExpr( new NameExpr( decl->location, "receiver" ) ),
+                        new CastExpr( decl->location, new AddressExpr( new NameExpr( decl->location, "receiver" ) ), new PointerType( new StructInstType( *actorDecl ) ), ExplicitCast ),
                         new AddressExpr( new NameExpr( decl->location, "msg" ) ),
+                        new CastExpr( decl->location, new AddressExpr( new NameExpr( decl->location, "msg" ) ), new PointerType( new StructInstType( *msgDecl ) ), ExplicitCast ),
                         new NameExpr( decl->location, "fn" )
+                                        }
 …
             FunctionDecl * sendOperatorFunction = new FunctionDecl(
                 decl->location,
                 "?<<?",
+                "?|?",
                 {},                     // forall
+                {
 …
     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/GenPoly/SpecializeNew.cpp

-              rfa5e1aa5
+              rb7b3e41
         using namespace ResolvExpr;
         ast::OpenVarSet openVars, closedVars;
+        ast::AssertionSet need, have;
+        findOpenVars( formalType, openVars, closedVars, need, have, FirstClosed );
+        findOpenVars( actualType, openVars, closedVars, need, have, FirstOpen );
+        ast::AssertionSet need, have; // unused
+        ast::TypeEnvironment env; // unused
+        // findOpenVars( formalType, openVars, closedVars, need, have, FirstClosed );
+        findOpenVars( actualType, openVars, closedVars, need, have, env, FirstOpen );
         for ( const ast::OpenVarSet::value_type & openVar : openVars ) {
                 const ast::Type * boundType = subs->lookup( openVar.first );
 …
                         if ( closedVars.find( *inst ) == closedVars.end() ) {
                                 return true;
+                        }
+                        else {
+                                assertf(false, "closed: %s", inst->name.c_str());
+                        }
                 // Otherwise, the variable is bound to a concrete type.

src/Parser/DeclarationNode.cc

-              rfa5e1aa5
+              rb7b3e41
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr Apr 20 11:46:00 2023
 // Update Count     : 1393
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Jun 17 14:41:48 2023
+// Update Count     : 1405
 //
 …
         std::vector<ast::ptr<ast::Expr>> exprs;
         buildList( expr, exprs );
+        newnode->attributes.push_back(
+                new ast::Attribute( *name, std::move( exprs ) ) );
+        newnode->attributes.push_back( new ast::Attribute( *name, std::move( exprs ) ) );
         delete name;
         return newnode;
 …
                                         dst->basictype = src->basictype;
                                 } else if ( src->basictype != DeclarationNode::NoBasicType )
+                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::basicTypeNames[ src->basictype ] + " in type: " );
+                                        SemanticError( yylloc, string( "multiple declaration types \"" ) + DeclarationNode::basicTypeNames[ dst->basictype ] +
+                                                                   "\" and \"" + DeclarationNode::basicTypeNames[ src->basictype ] + "\"." );
                                 if ( dst->complextype == DeclarationNode::NoComplexType ) {
                                         dst->complextype = src->complextype;
                                 } else if ( src->complextype != DeclarationNode::NoComplexType )
+                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::complexTypeNames[ src->complextype ] + " in type: " );
+                                        SemanticError( yylloc, string( "multiple declaration types \"" ) + DeclarationNode::complexTypeNames[ src->complextype ] +
+                                                                   "\" and \"" + DeclarationNode::complexTypeNames[ src->complextype ] + "\"." );
                                 if ( dst->signedness == DeclarationNode::NoSignedness ) {
                                         dst->signedness = src->signedness;
                                 } else if ( src->signedness != DeclarationNode::NoSignedness )
+                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::signednessNames[ src->signedness ] + " in type: " );
+                                        SemanticError( yylloc, string( "conflicting type specifier \"" ) + DeclarationNode::signednessNames[ dst->signedness ] +
+                                                                   "\" and \"" + DeclarationNode::signednessNames[ src->signedness ] + "\"." );
                                 if ( dst->length == DeclarationNode::NoLength ) {
 …
                                         dst->length = DeclarationNode::LongLong;
                                 } else if ( src->length != DeclarationNode::NoLength )
+                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::lengthNames[ src->length ] + " in type: " );
+                                        SemanticError( yylloc, string( "conflicting type specifier \"" ) + DeclarationNode::lengthNames[ dst->length ] +
+                                                                   "\" and \"" + DeclarationNode::lengthNames[ src->length ] + "\"." );
                         } // if
                         break;
 …
 DeclarationNode * DeclarationNode::addEnumBase( DeclarationNode * o ) {
         if ( o && o -> type)  {
+        if ( o && o->type)  {
                 type->base= o->type;
+        }
+        } // if
         delete o;
         return this;
 …
+}
 // If a typedef wraps an anonymous declaration, name the inner declaration
 // so it has a consistent name across translation units.
+// If a typedef wraps an anonymous declaration, name the inner declaration so it has a consistent name across
+// translation units.
 static void nameTypedefedDecl(
                 DeclarationNode * innerDecl,
 …
+}
+void buildList( DeclarationNode * firstNode,
+                std::vector<ast::ptr<ast::Decl>> & outputList ) {
+void buildList( DeclarationNode * firstNode, std::vector<ast::ptr<ast::Decl>> & outputList ) {
         SemanticErrorException errors;
         std::back_insert_iterator<std::vector<ast::ptr<ast::Decl>>> out( outputList );

src/Parser/ExpressionNode.cc

-              rfa5e1aa5
+              rb7b3e41
 ast::Expr * build_cast( const CodeLocation & location,
                 DeclarationNode * decl_node,
+                ExpressionNode * expr_node ) {
+                ExpressionNode * expr_node,
+                ast::CastExpr::CastKind kind ) {
         ast::Type * targetType = maybeMoveBuildType( decl_node );
         if ( dynamic_cast<ast::VoidType *>( targetType ) ) {
 …
                 return new ast::CastExpr( location,
                         maybeMoveBuild( expr_node ),
                         ast::ExplicitCast );
+                        ast::ExplicitCast, kind );
         } else {
                 return new ast::CastExpr( location,
                         maybeMoveBuild( expr_node ),
                         targetType,
                         ast::ExplicitCast );
+                        ast::ExplicitCast, kind );
         } // if
 } // build_cast

src/Parser/ExpressionNode.h

rfa5e1aa5	rb7b3e41
69	69	ast::DimensionExpr * build_dimensionref( const CodeLocation &, const std::string * name );
70	70
71		ast::Expr * build_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node );
	71	ast::Expr * build_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node, ast::CastExpr::CastKind kind = ast::CastExpr::Default );
72	72	ast::Expr * build_keyword_cast( const CodeLocation &, ast::AggregateDecl::Aggregate target, ExpressionNode * expr_node );
73	73	ast::Expr * build_virtual_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node );

src/Parser/lex.ll

-              rfa5e1aa5
+              rb7b3e41
  * 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
  */
 …
 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

-              rfa5e1aa5
+              rb7b3e41
 // 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 : Sat Jun 17 18:53:24 2023
+// Update Count     : 6347
 //
 …
         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
 …
 #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(
 …
 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 ) );
 …
                         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
 …
         // | 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; }
+        ;
 …
                 { $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $5 ), maybeMoveBuildType( $3 ) ) ); }
         | '(' RETURN type_no_function ')' cast_expression       // CFA
                 { SemanticError( yylloc, "Return cast is currently unimplemented." ); $$ = nullptr; }
+                { $$ = new ExpressionNode( build_cast( yylloc, $3, $5, ast::CastExpr::Return ) ); }
         | '(' COERCE type_no_function ')' cast_expression       // CFA
                 { SemanticError( yylloc, "Coerce cast is currently unimplemented." ); $$ = nullptr; }
 …
                 // FIX ME: computes $1 twice
         | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
                 { $$ = new ExpressionNode( build_cond( yylloc, $1, $1, $4 ) ); }
+                { $$ = new ExpressionNode( build_cond( yylloc, $1, $1->clone(), $4 ) ); }
+        ;
 …
         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." ) );
 …
         | 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; }
+        ;
 …
                         $$ = $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 ) ); }
 …
                         $$ = $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; }
+        ;
 …
 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; }
+        ;
 …
                         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; }
 …
+                {
                         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; }
 …
+                {
                         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; }
 …
+                {
                         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
 …
+                {
                         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 );
+                }
 …
+                {
                         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 );
+                }
 …
+                {
                         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
 …
         | 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;
+                }
 …
         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 ) );
+                }
 …
                 { $$ = 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 ) ); }
 …
                 { $$ = 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,
 …
                         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;
+                        }
+                }
 …
         | 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;
+                }
 …
                         // } // 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( $$ ); }
 …
         | 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 );
+                }
 …
         | 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
 …
         | 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
+                }
 …
         | 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
+                }
 …
         | 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
+                }
 …
                         $$ = $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/Candidate.hpp

-              rfa5e1aa5
+              rb7b3e41
 /// Holdover behaviour from old `findMinCost` -- xxx -- can maybe be eliminated?
+/*
 static inline void promoteCvtCost( CandidateList & candidates ) {
         for ( CandidateRef & r : candidates ) {
 …
+        }
+}
+*/
 void print( std::ostream & os, const Candidate & cand, Indenter indent = {} );

src/ResolvExpr/CandidateFinder.cpp

-              rfa5e1aa5
+              rb7b3e41
 #include "typeops.h"              // for combos
 #include "Unify.h"
+#include "WidenMode.h"
 #include "AST/Expr.hpp"
 #include "AST/Node.hpp"
 …
                         // attempt to narrow based on expected target type
                         const ast::Type * returnType = funcType->returns.front();
+                        if ( ! unify(
+                                returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen )
+                        ) {
+                                // unification failed, do not pursue this candidate
+                                return;
+                        if ( selfFinder.strictMode ) {
+                                if ( ! unifyExact(
+                                        returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, noWiden() ) // xxx - is no widening correct?
+                                ) {
+                                        // unification failed, do not pursue this candidate
+                                        return;
+                                }
+                        }
+                        else {
+                                if ( ! unify(
+                                        returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen )
+                                ) {
+                                        // unification failed, do not pursue this candidate
+                                        return;
+                                }
+                        }
+                }
 …
                                 for (size_t i=0; i<nParams; ++i) {
                                         auto obj = funcDecl->params[i].strict_as<ast::ObjectDecl>();
                                         if (!instantiateArgument( location,
+                                        if ( !instantiateArgument( location,
                                                 funcType->params[i], obj->init, args, results, genStart, symtab)) return;
+                                }
 …
                         // matches
                         // no default args for indirect calls
                         if ( ! instantiateArgument( location,
+                        if ( !instantiateArgument( location,
                                 param, nullptr, args, results, genStart, symtab ) ) return;
+                }
 …
                 if ( auto structInst = aggrExpr->result.as< ast::StructInstType >() ) {
                         addAggMembers( structInst, aggrExpr, *cand, Cost::safe, "" );
+                        addAggMembers( structInst, aggrExpr, *cand, Cost::unsafe, "" );
                 } else if ( auto unionInst = aggrExpr->result.as< ast::UnionInstType >() ) {
                         addAggMembers( unionInst, aggrExpr, *cand, Cost::safe, "" );
+                        addAggMembers( unionInst, aggrExpr, *cand, Cost::unsafe, "" );
+                }
+        }
 …
                                 if ( auto pointer = dynamic_cast< const ast::PointerType * >( funcResult ) ) {
                                         if ( auto function = pointer->base.as< ast::FunctionType >() ) {
+                                                // if (!selfFinder.allowVoid && function->returns.empty()) continue;
                                                 CandidateRef newFunc{ new Candidate{ *func } };
                                                 newFunc->expr =
 …
                                         if ( const ast::EqvClass * clz = func->env.lookup( *inst ) ) {
                                                 if ( auto function = clz->bound.as< ast::FunctionType >() ) {
                                                         CandidateRef newFunc{ new Candidate{ *func } };
+                                                        CandidateRef newFunc( new Candidate( *func ) );
                                                         newFunc->expr =
                                                                 referenceToRvalueConversion( newFunc->expr, newFunc->cost );
 …
                 if ( found.empty() && ! errors.isEmpty() ) { throw errors; }
+                // only keep the best matching intrinsic result to match C semantics (no unexpected narrowing/widening)
+                // TODO: keep one for each set of argument candidates?
+                Cost intrinsicCost = Cost::infinity;
+                CandidateList intrinsicResult;
                 // Compute conversion costs
                 for ( CandidateRef & withFunc : found ) {
 …
                         if ( cvtCost != Cost::infinity ) {
                                 withFunc->cvtCost = cvtCost;
+                                candidates.emplace_back( std::move( withFunc ) );
+                        }
+                }
+                                withFunc->cost += cvtCost;
+                                auto func = withFunc->expr.strict_as<ast::ApplicationExpr>()->func.as<ast::VariableExpr>();
+                                if (func && func->var->linkage == ast::Linkage::Intrinsic) {
+                                        if (withFunc->cost < intrinsicCost) {
+                                                intrinsicResult.clear();
+                                                intrinsicCost = withFunc->cost;
+                                        }
+                                        if (withFunc->cost == intrinsicCost) {
+                                                intrinsicResult.emplace_back(std::move(withFunc));
+                                        }
+                                }
+                                else {
+                                        candidates.emplace_back( std::move( withFunc ) );
+                                }
+                        }
+                }
+                spliceBegin( candidates, intrinsicResult );
                 found = std::move( candidates );
                 // use a new list so that candidates are not examined by addAnonConversions twice
                 CandidateList winners = findMinCost( found );
                 promoteCvtCost( winners );
+                // CandidateList winners = findMinCost( found );
+                // promoteCvtCost( winners );
                 // function may return a struct/union value, in which case we need to add candidates
                 // for implicit conversions to each of the anonymous members, which must happen after
                 // `findMinCost`, since anon conversions are never the cheapest
                 for ( const CandidateRef & c : winners ) {
+                for ( const CandidateRef & c : found ) {
                         addAnonConversions( c );
+                }
+                spliceBegin( candidates, winners );
+                if ( candidates.empty() && targetType && ! targetType->isVoid() ) {
+                // would this be too slow when we don't check cost anymore?
+                spliceBegin( candidates, found );
+                if ( candidates.empty() && targetType && ! targetType->isVoid() && !selfFinder.strictMode ) {
                         // If resolution is unsuccessful with a target type, try again without, since it
                         // will sometimes succeed when it wouldn't with a target type binding.
 …
                 CandidateFinder finder( context, tenv, toType );
+                if (toType->isVoid()) {
+                        finder.allowVoid = true;
+                }
+                if ( castExpr->kind == ast::CastExpr::Return ) {
+                        finder.strictMode = true;
+                        finder.find( castExpr->arg, ResolvMode::withAdjustment() );
+                        // return casts are eliminated (merely selecting an overload, no actual operation)
+                        candidates = std::move(finder.candidates);
+                }
                 finder.find( castExpr->arg, ResolvMode::withAdjustment() );
 …
                 CandidateList matches;
+                Cost minExprCost = Cost::infinity;
+                Cost minCastCost = Cost::infinity;
                 for ( CandidateRef & cand : finder.candidates ) {
                         ast::AssertionSet need( cand->need.begin(), cand->need.end() ), have;
 …
                                 // count one safe conversion for each value that is thrown away
                                 thisCost.incSafe( discardedValues );
+                                CandidateRef newCand = std::make_shared<Candidate>(
+                                        restructureCast( cand->expr, toType, castExpr->isGenerated ),
+                                        copy( cand->env ), std::move( open ), std::move( need ), cand->cost,
+                                        cand->cost + thisCost );
+                                inferParameters( newCand, matches );
+                        }
+                }
+                // select first on argument cost, then conversion cost
+                CandidateList minArgCost = findMinCost( matches );
+                promoteCvtCost( minArgCost );
+                candidates = findMinCost( minArgCost );
+                                // select first on argument cost, then conversion cost
+                                if ( cand->cost < minExprCost || ( cand->cost == minExprCost && thisCost < minCastCost ) ) {
+                                        minExprCost = cand->cost;
+                                        minCastCost = thisCost;
+                                        matches.clear();
+                                }
+                                // ambiguous case, still output candidates to print in error message
+                                if ( cand->cost == minExprCost && thisCost == minCastCost ) {
+                                        CandidateRef newCand = std::make_shared<Candidate>(
+                                                restructureCast( cand->expr, toType, castExpr->isGenerated ),
+                                                copy( cand->env ), std::move( open ), std::move( need ), cand->cost + thisCost);
+                                        // currently assertions are always resolved immediately so this should have no effect.
+                                        // if this somehow changes in the future (e.g. delayed by indeterminate return type)
+                                        // we may need to revisit the logic.
+                                        inferParameters( newCand, matches );
+                                }
+                                // else skip, better alternatives found
+                        }
+                }
+                candidates = std::move(matches);
+                //CandidateList minArgCost = findMinCost( matches );
+                //promoteCvtCost( minArgCost );
+                //candidates = findMinCost( minArgCost );
+        }
 …
                 // candidates for true result
                 CandidateFinder finder2( context, tenv );
+                finder2.allowVoid = true;
                 finder2.find( conditionalExpr->arg2, ResolvMode::withAdjustment() );
                 if ( finder2.candidates.empty() ) return;
 …
                 // candidates for false result
                 CandidateFinder finder3( context, tenv );
+                finder3.allowVoid = true;
                 finder3.find( conditionalExpr->arg3, ResolvMode::withAdjustment() );
                 if ( finder3.candidates.empty() ) return;
 …
         void Finder::postvisit( const ast::ConstructorExpr * ctorExpr ) {
                 CandidateFinder finder( context, tenv );
+                finder.allowVoid = true;
                 finder.find( ctorExpr->callExpr, ResolvMode::withoutPrune() );
                 for ( CandidateRef & r : finder.candidates ) {
 …
                         CandidateFinder finder( context, tenv, toType );
                         finder.find( initExpr->expr, ResolvMode::withAdjustment() );
+                        Cost minExprCost = Cost::infinity;
+                        Cost minCastCost = Cost::infinity;
                         for ( CandidateRef & cand : finder.candidates ) {
                                 if (reason.code == NotFound) reason.code = NoMatch;
 …
                                         // count one safe conversion for each value that is thrown away
                                         thisCost.incSafe( discardedValues );
+                                        CandidateRef newCand = std::make_shared<Candidate>(
+                                                new ast::InitExpr{
+                                                        initExpr->location, restructureCast( cand->expr, toType ),
+                                                        initAlt.designation },
+                                                std::move(env), std::move( open ), std::move( need ), cand->cost, thisCost );
+                                        inferParameters( newCand, matches );
+                                        if ( cand->cost < minExprCost || ( cand->cost == minExprCost && thisCost < minCastCost ) ) {
+                                                minExprCost = cand->cost;
+                                                minCastCost = thisCost;
+                                                matches.clear();
+                                        }
+                                        // ambiguous case, still output candidates to print in error message
+                                        if ( cand->cost == minExprCost && thisCost == minCastCost ) {
+                                                CandidateRef newCand = std::make_shared<Candidate>(
+                                                        new ast::InitExpr{
+                                                                initExpr->location,
+                                                                restructureCast( cand->expr, toType ),
+                                                                initAlt.designation },
+                                                        std::move(env), std::move( open ), std::move( need ), cand->cost + thisCost );
+                                                // currently assertions are always resolved immediately so this should have no effect.
+                                                // if this somehow changes in the future (e.g. delayed by indeterminate return type)
+                                                // we may need to revisit the logic.
+                                                inferParameters( newCand, matches );
+                                        }
+                                }
+                        }
 …
                 // select first on argument cost, then conversion cost
+                CandidateList minArgCost = findMinCost( matches );
+                promoteCvtCost( minArgCost );
+                candidates = findMinCost( minArgCost );
+                // CandidateList minArgCost = findMinCost( matches );
+                // promoteCvtCost( minArgCost );
+                // candidates = findMinCost( minArgCost );
+                candidates = std::move(matches);
+        }
 …
                         auto found = selected.find( mangleName );
                         if ( found != selected.end() ) {
+                                if ( newCand->cost < found->second.candidate->cost ) {
+                                // tiebreaking by picking the lower cost on CURRENT expression
+                                // NOTE: this behavior is different from C semantics.
+                                // Specific remediations are performed for C operators at postvisit(UntypedExpr).
+                                // Further investigations may take place.
+                                if ( newCand->cost < found->second.candidate->cost
+                                        || (newCand->cost == found->second.candidate->cost && newCand->cvtCost < found->second.candidate->cvtCost) ) {
                                         PRINT(
                                                 std::cerr << "cost " << newCand->cost << " beats "
 …
                                         found->second = PruneStruct{ newCand };
                                 } else if ( newCand->cost == found->second.candidate->cost ) {
+                                } else if ( newCand->cost == found->second.candidate->cost && newCand->cvtCost == found->second.candidate->cvtCost ) {
                                         // if one of the candidates contains a deleted identifier, can pick the other,
                                         // since deleted expressions should not be ambiguous if there is another option
 …
         */
+        if ( mode.prune ) {
+        // optimization: don't prune for NameExpr since it never has cost
+        if ( mode.prune && !dynamic_cast<const ast::NameExpr *>(expr) ) {
                 // trim candidates to single best one
                 PRINT(

src/ResolvExpr/CandidateFinder.hpp

rfa5e1aa5	rb7b3e41
33	33	const ast::TypeEnvironment & env; ///< Substitutions performed in this resolution
34	34	ast::ptr< ast::Type > targetType; ///< Target type for resolution
	35	bool strictMode = false; ///< If set to true, requires targetType to be exact match (inside return cast)
	36	bool allowVoid = false; ///< If set to true, allow void-returning function calls (only top level, cast to void and first in comma)
35	37	std::set< std::string > otypeKeys; /// different type may map to same key
36	38

src/ResolvExpr/CastCost.cc

-              rfa5e1aa5
+              rb7b3e41
         if ( typesCompatibleIgnoreQualifiers( src, dst, env ) ) {
                 PRINT( std::cerr << "compatible!" << std::endl; )
+                if (dynamic_cast<const ast::ZeroType *>(dst) || dynamic_cast<const ast::OneType *>(dst)) {
+                        return Cost::spec;
+                }
                 return Cost::zero;
         } else if ( dynamic_cast< const ast::VoidType * >( dst ) ) {

src/ResolvExpr/CommonType.cc

-              rfa5e1aa5
+              rb7b3e41
                         if ( auto basic2 = dynamic_cast< const ast::BasicType * >( type2 ) ) {
                                 #warning remove casts when `commonTypes` moved to new AST
+                                /*
                                 ast::BasicType::Kind kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)basic2->kind ];
                                 if (
 …
                                         result = new ast::BasicType{ kind, basic->qualifiers | basic2->qualifiers };
+                                }
+                                */
+                                ast::BasicType::Kind kind;
+                                if (basic->kind != basic2->kind && !widen.first && !widen.second) return;
+                                else if (!widen.first) kind = basic->kind; // widen.second
+                                else if (!widen.second) kind = basic2->kind;
+                                else kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)basic2->kind ];
+                                // xxx - what does qualifiers even do here??
+                                if ( (basic->qualifiers >= basic2->qualifiers || widen.first)
+                                        && (basic->qualifiers <= basic2->qualifiers || widen.second) ) {
+                                        result = new ast::BasicType{ kind, basic->qualifiers | basic2->qualifiers };
+                                }
                         } else if (
                                 dynamic_cast< const ast::ZeroType * >( type2 )
 …
                                 #warning remove casts when `commonTypes` moved to new AST
                                 ast::BasicType::Kind kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)ast::BasicType::SignedInt ];
+                                if (
+                                        ( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers )
+                                /*
+                                if ( // xxx - what does qualifier even do here??
+                                        ( ( basic->qualifiers >= type2->qualifiers )
                                                 || widen.first )
                                         && ( ( kind != basic->kind && basic->qualifiers <= type2->qualifiers )
+                                         && ( ( /* kind != basic->kind && basic->qualifiers <= type2->qualifiers )
                                                 || widen.second )
+                                ) {
+                                        result = new ast::BasicType{ kind, basic->qualifiers | type2->qualifiers };
+                                )
+                                */
+                                if (widen.second) {
+                                        result = new ast::BasicType{ basic->kind, basic->qualifiers | type2->qualifiers };
+                                }
                         } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( type2 ) ) {
 …
                                 auto entry = open.find( *var );
                                 if ( entry != open.end() ) {
+                                // if (tenv.lookup(*var)) {
                                         ast::AssertionSet need, have;
                                         if ( ! tenv.bindVar(
 …
                 void postvisit( const ast::TraitInstType * ) {}
                 void postvisit( const ast::TypeInstType * inst ) {}
                 void postvisit( const ast::TupleType * tuple) {
+                void postvisit( const ast::TypeInstType * ) {}
+                void postvisit( const ast::TupleType * tuple ) {
                         tryResolveWithTypedEnum( tuple );
+                }

src/ResolvExpr/ConversionCost.cc

-              rfa5e1aa5
+              rb7b3e41
         cost = costCalc( refType->base, dst, srcIsLvalue, symtab, env );
+        // xxx - should qualifiers be considered in pass-by-value?
+        /*
         if ( refType->base->qualifiers == dst->qualifiers ) {
                 cost.incReference();
 …
                 cost.incUnsafe();
+        }
+        */
+        cost.incReference();
+}
 …
                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
+                }
+                // this has the effect of letting any expr such as x+0, x+1 to be typed
+                // the same as x, instead of at least int. are we willing to sacrifice this little
+                // bit of coherence with C?
+                // TODO: currently this does not work when no zero/one overloads exist. Find a fix for it.
+                // cost = Cost::zero;
         } else if ( dynamic_cast< const ast::PointerType * >( dst ) ) {
                 cost = Cost::zero;
                 // +1 for zero_t ->, +1 for disambiguation
                 cost.incSafe( maxIntCost + 2 );
+                // assuming 0p is supposed to be used for pointers?
+        }
+}
 …
                 cost = Cost::zero;
         } else if ( const ast::BasicType * dstAsBasic =
                         dynamic_cast< const ast::BasicType * >( dst ) ) {
+                        dynamic_cast< const ast::BasicType * >( dst ) ) {
                 int tableResult = costMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ];
                 if ( -1 == tableResult ) {
 …
                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
+                }
+                // cost = Cost::zero;
+        }
+}

src/ResolvExpr/CurrentObject.cc

-              rfa5e1aa5
+              rb7b3e41
                         auto arg = eval( expr );
+                        index = arg.first;
+                        assertf( arg.hasKnownValue, "Non-evaluable expression made it to IndexIterator" );
+                        index = arg.knownValue;
                         // if ( auto constExpr = dynamic_cast< const ConstantExpr * >( expr ) ) {
 …
                 size_t getSize( const Expr * expr ) {
                         auto res = eval( expr );
                         if ( !res.second ) {
+                        if ( !res.hasKnownValue ) {
                                 SemanticError( location, toString( "Array designator must be a constant expression: ", expr ) );
+                        }
                         return res.first;
+                        return res.knownValue;
+                }

src/ResolvExpr/FindOpenVars.cc

-              rfa5e1aa5
+              rb7b3e41
 #include "AST/Pass.hpp"
 #include "AST/Type.hpp"
+#include "AST/TypeEnvironment.hpp"
 #include "Common/PassVisitor.h"
 #include "SynTree/Declaration.h"  // for TypeDecl, DeclarationWithType (ptr ...
 #include "SynTree/Type.h"         // for Type, Type::ForallList, ArrayType
+#include <iostream>
 namespace ResolvExpr {
 …
                         ast::AssertionSet & need;
                         ast::AssertionSet & have;
+                        ast::TypeEnvironment & env;
                         bool nextIsOpen;
                         FindOpenVars_new(
                                 ast::OpenVarSet & o, ast::OpenVarSet & c, ast::AssertionSet & n,
                                 ast::AssertionSet & h, FirstMode firstIsOpen )
                         : open( o ), closed( c ), need( n ), have( h ), nextIsOpen( firstIsOpen ) {}
+                                ast::AssertionSet & h, ast::TypeEnvironment & env, FirstMode firstIsOpen )
+                        : open( o ), closed( c ), need( n ), have( h ), env (env), nextIsOpen( firstIsOpen ) {}
                         void previsit( const ast::FunctionType * type ) {
                                 // mark open/closed variables
                                 if ( nextIsOpen ) {
+                                        // trying to remove this from resolver.
+                                        // occasionally used in other parts so not deleting right now.
+                                        // insert open variables unbound to environment.
+                                        env.add(type->forall);
                                         for ( auto & decl : type->forall ) {
                                                 open[ *decl ] = ast::TypeData{ decl->base };
 …
         void findOpenVars(
                         const ast::Type * type, ast::OpenVarSet & open, ast::OpenVarSet & closed,
                         ast::AssertionSet & need, ast::AssertionSet & have, FirstMode firstIsOpen ) {
                 ast::Pass< FindOpenVars_new > finder{ open, closed, need, have, firstIsOpen };
+                        ast::AssertionSet & need, ast::AssertionSet & have, ast::TypeEnvironment & env, FirstMode firstIsOpen ) {
+                ast::Pass< FindOpenVars_new > finder{ open, closed, need, have, env, firstIsOpen };
                 type->accept( finder );
+                if (!closed.empty()) {
+                        std::cerr << "closed: ";
+                        for (auto& i : closed) {
+                                std::cerr << i.first.base->location << ":" << i.first.base->name << ' ';
+                        }
+                        std::cerr << std::endl;
+                }
+        }
 } // namespace ResolvExpr

src/ResolvExpr/FindOpenVars.h

rfa5e1aa5	rb7b3e41
33	33	void findOpenVars(
34	34	const ast::Type * type, ast::OpenVarSet & open, ast::OpenVarSet & closed,
35		ast::AssertionSet & need, ast::AssertionSet & have, FirstMode firstIsOpen );
	35	ast::AssertionSet & need, ast::AssertionSet & have, ast::TypeEnvironment & env, FirstMode firstIsOpen );
36	36	} // namespace ResolvExpr
37	37

src/ResolvExpr/Resolver.cc

-              rfa5e1aa5
+              rb7b3e41
                         ast::TypeEnvironment env;
                         CandidateFinder finder( context, env );
+                        finder.allowVoid = true;
                         finder.find( untyped, recursion_level == 1 ? mode.atTopLevel() : mode );
                         --recursion_level;
 …
                         // promote candidate.cvtCost to .cost
                         promoteCvtCost( winners );
+                        // promoteCvtCost( winners );
                         // produce ambiguous errors, if applicable
 …
                 /// 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 ) ) {
 …
                 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;
+        }
 …
                 static size_t traceId;
                 Resolver_new( const ast::TranslationGlobal & global ) :
+                        ast::WithSymbolTable(ast::SymbolTable::ErrorDetection::ValidateOnAdd),
                         context{ symtab, global } {}
                 Resolver_new( const ResolveContext & context ) :
 …
                                         auto mutAttr = mutate(attr);
                                         mutAttr->params.front() = resolved;
                                         if (! result.second) {
+                                        if (! result.hasKnownValue) {
                                                 SemanticWarning(loc, Warning::GccAttributes,
                                                         toCString( name, " priorities must be integers from 0 to 65535 inclusive: ", arg ) );
+                                        }
                                         else {
                                                 auto priority = result.first;
+                                                auto priority = result.knownValue;
                                                 if (priority < 101) {
                                                         SemanticWarning(loc, Warning::GccAttributes,
 …
                 const ast::Type * initContext = currentObject.getCurrentType();
                 removeExtraneousCast( newExpr, symtab );
+                removeExtraneousCast( newExpr );
                 // check if actual object's type is char[]

src/ResolvExpr/SatisfyAssertions.cpp

-              rfa5e1aa5
+              rb7b3e41
 #include "SatisfyAssertions.hpp"
+#include <iostream>
 #include <algorithm>
 #include <cassert>
 …
 #include "SymTab/Mangler.h"
 namespace ResolvExpr {
 …
                         ast::AssertionSet && h, ast::AssertionSet && n, ast::OpenVarSet && o, ast::UniqueId rs )
                 : cdata( c ), adjType( at ), env( std::move( e ) ), have( std::move( h ) ),
+                  need( std::move( n ) ), open( std::move( o ) ), resnSlot( rs ) {}
+                  need( std::move( n ) ), open( std::move( o ) ), resnSlot( rs ) {
+                        if (!have.empty()) {
+                                // std::cerr << c.id->location << ':' << c.id->name << std::endl; // I think this was debugging code so I commented it
+                        }
+                  }
         };
 …
         };
+        /// Adds a captured assertion to the symbol table
+        void addToSymbolTable( const ast::AssertionSet & have, ast::SymbolTable & symtab ) {
+                for ( auto & i : have ) {
+                        if ( i.second.isUsed ) { symtab.addId( i.first->var ); }
+                }
+        }
+        enum AssertionResult {Fail, Skip, Success} ;
         /// Binds a single assertion, updating satisfaction state
 …
                         "Assertion candidate does not have a unique ID: %s", toString( candidate ).c_str() );
                 ast::Expr * varExpr = match.cdata.combine( cand->expr->location, cand->cvtCost );
+                ast::Expr * varExpr = match.cdata.combine( cand->expr->location, cand->cost );
                 varExpr->result = match.adjType;
                 if ( match.resnSlot ) { varExpr->inferred.resnSlots().emplace_back( match.resnSlot ); }
 …
         /// Satisfy a single assertion
         bool satisfyAssertion( ast::AssertionList::value_type & assn, SatState & sat, bool allowConversion = false, bool skipUnbound = false) {
+        AssertionResult satisfyAssertion( ast::AssertionList::value_type & assn, SatState & sat, bool skipUnbound = false) {
                 // skip unused assertions
+                if ( ! assn.second.isUsed ) return true;
+                // static unsigned int cnt = 0; // I think this was debugging code so I commented it
+                if ( ! assn.second.isUsed ) return AssertionResult::Success;
+                // if (assn.first->var->name[1] == '|') std::cerr << ++cnt << std::endl; // I think this was debugging code so I commented it
                 // find candidates that unify with the desired type
                 AssnCandidateList matches;
+                AssnCandidateList matches, inexactMatches;
                 std::vector<ast::SymbolTable::IdData> candidates;
 …
                                 .strict_as<ast::FunctionType>()->params[0]
                                 .strict_as<ast::ReferenceType>()->base;
+                        sat.cand->env.apply(thisArgType);
+                        // sat.cand->env.apply(thisArgType);
+                        if (auto inst = thisArgType.as<ast::TypeInstType>()) {
+                                auto cls = sat.cand->env.lookup(*inst);
+                                if (cls && cls->bound) thisArgType = cls->bound;
+                        }
                         std::string otypeKey = "";
                         if (thisArgType.as<ast::PointerType>()) otypeKey = Mangle::Encoding::pointer;
                         else if (!isUnboundType(thisArgType)) otypeKey = Mangle::mangle(thisArgType, Mangle::Type | Mangle::NoGenericParams);
                         else if (skipUnbound) return false;
+                        else if (skipUnbound) return AssertionResult::Skip;
                         candidates = sat.symtab.specialLookupId(kind, otypeKey);
 …
                         ast::OpenVarSet closed;
+                        findOpenVars( toType, newOpen, closed, newNeed, have, FirstClosed );
+                        findOpenVars( adjType, newOpen, closed, newNeed, have, FirstOpen );
+                        if ( allowConversion ) {
+                        // findOpenVars( toType, newOpen, closed, newNeed, have, FirstClosed );
+                        findOpenVars( adjType, newOpen, closed, newNeed, have, newEnv, FirstOpen );
+                        ast::TypeEnvironment tempNewEnv {newEnv};
+                        if ( unifyExact( toType, adjType, tempNewEnv, newNeed, have, newOpen, WidenMode {true, true} ) ) {
+                                // set up binding slot for recursive assertions
+                                ast::UniqueId crntResnSlot = 0;
+                                if ( ! newNeed.empty() ) {
+                                        crntResnSlot = ++globalResnSlot;
+                                        for ( auto & a : newNeed ) { a.second.resnSlot = crntResnSlot; }
+                                }
+                                matches.emplace_back(
+                                        cdata, adjType, std::move( tempNewEnv ), std::move( have ), std::move( newNeed ),
+                                        std::move( newOpen ), crntResnSlot );
+                        }
+                        else if ( matches.empty() ) {
+                                // restore invalidated env
+                                // newEnv = sat.cand->env;
+                                // newNeed.clear();
                                 if ( auto c = commonType( toType, adjType, newEnv, newNeed, have, newOpen, WidenMode {true, true} ) ) {
                                         // set up binding slot for recursive assertions
 …
+                                        }
                                         matches.emplace_back(
+                                        inexactMatches.emplace_back(
                                                 cdata, adjType, std::move( newEnv ), std::move( have ), std::move( newNeed ),
                                                 std::move( newOpen ), crntResnSlot );
+                                }
+                        }
-                        else {
-                                if ( unifyExact( toType, adjType, newEnv, newNeed, have, newOpen, WidenMode {true, true} ) ) {
-                                        // set up binding slot for recursive assertions
-                                        ast::UniqueId crntResnSlot = 0;
-                                        if ( ! newNeed.empty() ) {
-                                                crntResnSlot = ++globalResnSlot;
-                                                for ( auto & a : newNeed ) { a.second.resnSlot = crntResnSlot; }
+                                        }
-                                        matches.emplace_back(
-                                                cdata, adjType, std::move( newEnv ), std::move( have ), std::move( newNeed ),
-                                                std::move( newOpen ), crntResnSlot );
+                                }
+                        }
+                }
                 // break if no satisfying match
+                if ( matches.empty() ) return false;
+                if ( matches.empty() ) matches = std::move(inexactMatches);
+                if ( matches.empty() ) return AssertionResult::Fail;
                 // defer if too many satisfying matches
                 if ( matches.size() > 1 ) {
                         sat.deferred.emplace_back( assn.first, assn.second, std::move( matches ) );
                         return true;
+                        return AssertionResult::Success;
+                }
                 // otherwise bind unique match in ongoing scope
                 AssnCandidate & match = matches.front();
                 addToSymbolTable( match.have, sat.symtab );
+                // addToSymbolTable( match.have, sat.symtab );
                 sat.newNeed.insert( match.need.begin(), match.need.end() );
                 sat.cand->env = std::move( match.env );
 …
                 bindAssertion( assn.first, assn.second, sat.cand, match, sat.inferred );
                 return true;
+                return AssertionResult::Success;
+        }
 …
                 // for each current mutually-compatible set of assertions
                 for ( SatState & sat : sats ) {
-                        bool allowConversion = false;
                         // stop this branch if a better option is already found
                         auto it = thresholds.find( pruneKey( *sat.cand ) );
 …
                         for (unsigned resetCount = 0; ; ++resetCount) {
                                 ast::AssertionList next;
-                                resetTyVarRenaming();
                                 // make initial pass at matching assertions
                                 for ( auto & assn : sat.need ) {
+                                        resetTyVarRenaming();
                                         // fail early if any assertion is not satisfiable
+                                        if ( ! satisfyAssertion( assn, sat, allowConversion, !next.empty() ) ) {
+                                                next.emplace_back(assn);
+                                                // goto nextSat;
+                                        }
+                                }
+                                // success
+                                if (next.empty()) break;
+                                // fail if nothing resolves
+                                else if (next.size() == sat.need.size()) {
+                                        if (allowConversion) {
+                                        auto result = satisfyAssertion( assn, sat, !next.empty() );
+                                        if ( result == AssertionResult::Fail ) {
                                                 Indenter tabs{ 3 };
                                                 std::ostringstream ss;
 …
                                                 print( ss, *sat.cand, ++tabs );
                                                 ss << (tabs-1) << "Could not satisfy assertion:\n";
                                                 ast::print( ss, next[0].first, tabs );
+                                                ast::print( ss, assn.first, tabs );
                                                 errors.emplace_back( ss.str() );
                                                 goto nextSat;
+                                        }
+                                        else {
+                                                allowConversion = true;
+                                                continue;
+                                        }
+                                }
+                                allowConversion = false;
+                                        else if ( result == AssertionResult::Skip ) {
+                                                next.emplace_back(assn);
+                                                // goto nextSat;
+                                        }
+                                }
+                                // success
+                                if (next.empty()) break;
                                 sat.need = std::move(next);
+                        }
 …
                                                 sat.cand->expr, std::move( compat.env ), std::move( compat.open ),
                                                 ast::AssertionSet{} /* need moved into satisfaction state */,
                                                 sat.cand->cost, sat.cand->cvtCost );
+                                                sat.cand->cost );
                                         ast::AssertionSet nextNewNeed{ sat.newNeed };
 …
                                         for ( DeferRef r : compat.assns ) {
                                                 AssnCandidate match = r.match;
                                                 addToSymbolTable( match.have, nextSymtab );
+                                                // addToSymbolTable( match.have, nextSymtab );
                                                 nextNewNeed.insert( match.need.begin(), match.need.end() );

src/ResolvExpr/Unify.cc

-              rfa5e1aa5
+              rb7b3e41
                 env.apply( newSecond );
                 findOpenVars( newFirst, open, closed, need, have, FirstClosed );
                 findOpenVars( newSecond, open, closed, need, have, FirstOpen );
+                // findOpenVars( newFirst, open, closed, need, have, FirstClosed );
+                findOpenVars( newSecond, open, closed, need, have, newEnv, FirstOpen );
                 return unifyExact(newFirst, newSecond, newEnv, need, have, open, noWiden() );
 …
                         // check that the other type is compatible and named the same
                         auto otherInst = dynamic_cast< const XInstType * >( other );
+                        if (otherInst && inst->name == otherInst->name) this->result = otherInst;
+                        if (otherInst && inst->name == otherInst->name)
+                                this->result = otherInst;
                         return otherInst;
+                }
 …
                 void postvisit( const ast::TypeInstType * typeInst ) {
+                        assert( open.find( *typeInst ) == open.end() );
+                        handleRefType( typeInst, type2 );
+                        // assert( open.find( *typeInst ) == open.end() );
+                        auto otherInst = dynamic_cast< const ast::TypeInstType * >( type2 );
+                        if (otherInst && typeInst->name == otherInst->name)
+                                this->result = otherInst;
+                        // return otherInst;
+                }
 …
         ) {
                 ast::OpenVarSet closed;
                 findOpenVars( type1, open, closed, need, have, FirstClosed );
                 findOpenVars( type2, open, closed, need, have, FirstOpen );
+                // findOpenVars( type1, open, closed, need, have, FirstClosed );
+                findOpenVars( type2, open, closed, need, have, env, FirstOpen );
                 return unifyInexact(
                         type1, type2, env, need, have, open, WidenMode{ true, true }, common );
 …
                         entry1 = var1 ? open.find( *var1 ) : open.end(),
                         entry2 = var2 ? open.find( *var2 ) : open.end();
+                bool isopen1 = entry1 != open.end();
+                bool isopen2 = entry2 != open.end();
+                // bool isopen1 = entry1 != open.end();
+                // bool isopen2 = entry2 != open.end();
+                bool isopen1 = var1 && env.lookup(*var1);
+                bool isopen2 = var2 && env.lookup(*var2);
+                /*
                 if ( isopen1 && isopen2 ) {
                         if ( entry1->second.kind != entry2->second.kind ) return false;
 …
                         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 );
+                } else {
+                        return env.bindVar( var2, type1, entry2->second, need, have, open, widen, symtab );
+                } */
+                if ( isopen1 && isopen2 ) {
+                        if ( var1->base->kind != var2->base->kind ) return false;
+                        return env.bindVarToVar(
+                                var1, var2, ast::TypeData{ var1->base->kind, var1->base->sized||var2->base->sized }, need, have,
+                                open, widen );
+                } else if ( isopen1 ) {
+                        return env.bindVar( var1, type2, ast::TypeData{var1->base}, need, have, open, widen );
+                } else if ( isopen2 ) {
+                        return env.bindVar( var2, type1, ast::TypeData{var2->base}, need, have, open, widen );
+                }else {
                         return ast::Pass<Unify_new>::read(
                                 type1, type2, env, need, have, open, widen );
+                }
+        }

src/SynTree/Expression.cc

rfa5e1aa5	rb7b3e41
267	267	}
268	268
269		CastExpr::CastExpr( Expression * arg, Type * toType, bool isGenerated ~~) : arg(arg), isGenerated( isGenerate~~d ) {
	269	CastExpr::CastExpr( Expression * arg, Type * toType, bool isGenerated, CastKind kind ) : arg(arg), isGenerated( isGenerated ), kind( kind ) {
270	270	set_result(toType);
271	271	}
272	272
273		CastExpr::CastExpr( Expression * arg, bool isGenerated ~~) : arg(arg), isGenerated( isGenerate~~d ) {
	273	CastExpr::CastExpr( Expression * arg, bool isGenerated, CastKind kind ) : arg(arg), isGenerated( isGenerated ), kind( kind ) {
274	274	set_result( new VoidType( Type::Qualifiers() ) );
275	275	}
276	276
277		CastExpr::CastExpr( const CastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
	277	CastExpr::CastExpr( const CastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ), kind( other.kind ) {
278	278	}
279	279

src/SynTree/Expression.h

-              rfa5e1aa5
+              rb7b3e41
         bool isGenerated = true;
+        CastExpr( Expression * arg, bool isGenerated = true );
+        CastExpr( Expression * arg, Type * toType, bool isGenerated = true );
+        enum CastKind {
+                Default, // C
+                Coerce, // reinterpret cast
+                Return  // overload selection
+        };
+        CastKind kind = Default;
+        CastExpr( Expression * arg, bool isGenerated = true, CastKind kind = Default );
+        CastExpr( Expression * arg, Type * toType, bool isGenerated = true, CastKind kind = Default );
         CastExpr( Expression * arg, void * ) = delete; // prevent accidentally passing pointers for isGenerated in the first constructor
         CastExpr( const CastExpr & other );

src/Tuples/TupleAssignment.cc

rfa5e1aa5	rb7b3e41
679	679
680	680	ResolvExpr::CandidateFinder finder( crntFinder.context, matcher->env );
	681	finder.allowVoid = true;
681	682
682	683	try {

src/Validate/Autogen.cpp

-              rfa5e1aa5
+              rb7b3e41
 void FuncGenerator::produceDecl( const ast::FunctionDecl * decl ) {
         assert( nullptr != decl->stmts );
+        assert( decl->type_params.size() == getGenericParams( type ).size() );
         definitions.push_back( decl );
 …
                 decl->init = nullptr;
                 splice( assertions, decl->assertions );
                 oldToNew.emplace( std::make_pair( old_param, decl ) );
+                oldToNew.emplace( old_param, decl );
                 type_params.push_back( decl );
+        }
 …
         InitTweak::InitExpander_new srcParam( src );
         // Assign to destination.
         ast::Expr * dstSelect = new ast::MemberExpr(
+        ast::MemberExpr * dstSelect = new ast::MemberExpr(
                 location,
                 field,
 …
+                }
                 ast::Expr * srcSelect = (srcParam) ? new ast::MemberExpr(
+                ast::MemberExpr * srcSelect = (srcParam) ? new ast::MemberExpr(
                         location, field, new ast::VariableExpr( location, srcParam )
                 ) : nullptr;

src/Validate/HoistStruct.cpp

-              rfa5e1aa5
+              rb7b3e41
 #include <sstream>
+#include "AST/DeclReplacer.hpp"
 #include "AST/Pass.hpp"
 #include "AST/TranslationUnit.hpp"
+#include "AST/Vector.hpp"
 namespace Validate {
 …
         template<typename AggrDecl>
         AggrDecl const * postAggregate( AggrDecl const * );
+        template<typename InstType>
+        InstType const * preCollectionInstType( InstType const * type );
         ast::AggregateDecl const * parent = nullptr;
 …
         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 );
+}
 …
                 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;
+}
 …
+}
+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 ) {
 …
 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/Virtual/VirtualDtor.cpp

-              rfa5e1aa5
+              rb7b3e41
             CompoundStmt * dtorBody = mutate( decl->stmts.get() );
             // Adds the following to the end of any actor/message dtor:
+            // Adds the following to the start of any actor/message dtor:
             //  __CFA_dtor_shutdown( this );
+            dtorBody->push_front( new ExprStmt(
+                decl->location,
+                                new UntypedExpr (
+                    decl->location,
+                                        new NameExpr( decl->location, "__CFA_dtor_shutdown" ),
+                                        {
+                        new NameExpr( decl->location, decl->params.at(0)->name )
+                                        }
+                                )
+                        ));
+            dtorBody->push_front(
+                new IfStmt( decl->location,
+                    new UntypedExpr (
+                        decl->location,
+                        new NameExpr( decl->location, "__CFA_dtor_shutdown" ),
+                        {
+                            new NameExpr( decl->location, decl->params.at(0)->name )
+                        }
+                    ),
+                    new ReturnStmt( decl->location, nullptr )
+                )
+            );
             return;
+        }

src/main.cc

-              rfa5e1aa5
+              rb7b3e41
 #include <list>                             // for list
 #include <string>                           // for char_traits, operator<<
-using namespace std;
 #include "AST/Convert.hpp"
 …
 #include "Virtual/VirtualDtor.hpp"           // for implementVirtDtors
+using namespace std;
 static void NewPass( const char * const name ) {
         Stats::Heap::newPass( name );
 …
                 PASS( "Fix Qualified Types", Validate::fixQualifiedTypes, transUnit );
+                PASS( "Eliminate Typedef", Validate::eliminateTypedef, transUnit );
                 PASS( "Hoist Struct", Validate::hoistStruct, transUnit );
-                PASS( "Eliminate Typedef", Validate::eliminateTypedef, transUnit );
                 PASS( "Validate Generic Parameters", Validate::fillGenericParameters, transUnit );
                 PASS( "Translate Dimensions", Validate::translateDimensionParameters, transUnit );

Context Navigation

Legend:

Download in other formats: