Changeset 640b3df for src

src/AST/Create.cpp

r1180175	r640b3df
20	20	#include "AST/Decl.hpp"
21	21	#include "AST/Type.hpp"
	22	#include "Common/Iterate.hpp"
22	23
23	24	namespace ast {

src/AST/Decl.cpp

r1180175	r640b3df
20	20	#include <unordered_map>
21	21
22		#include "Common/~~utility.h"~~
	22	#include "Common/Eval.h" // for eval
23	23
24	24	#include "Fwd.hpp" // for UniqueId

src/AST/Pass.impl.hpp

r1180175	r640b3df
22	22	#include "AST/TranslationUnit.hpp"
23	23	#include "AST/TypeSubstitution.hpp"
	24	#include "Common/Iterate.hpp"
24	25
25	26	#define VISIT_START( node ) \

src/AST/Pass.proto.hpp

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

src/AST/porting.md

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

src/Common/Eval.cc

-              r1180175
+              r640b3df
 // file "LICENCE" distributed with Cforall.
 //
 // utility.h --
+// Eval.cc -- Evaluate parts of the ast at compile time.
 //
 // Author           : Richard C. Bilson
 …
 // Update Count     : 119
 //
+#include "Eval.h"
 #include <utility> // for pair

src/Common/module.mk

-              r1180175
+              r640b3df
         Common/CodeLocationTools.hpp \
         Common/CodeLocationTools.cpp \
-        Common/CompilerError.h \
         Common/Debug.h \
         Common/DeclStats.hpp \
 …
         Common/ErrorObjects.h \
         Common/Eval.cc \
+        Common/Eval.h \
         Common/Examine.cc \
         Common/Examine.h \
 …
         Common/Indenter.h \
         Common/Indenter.cc \
+        Common/Iterate.hpp \
         Common/PassVisitor.cc \
         Common/PassVisitor.h \
 …
         Common/Stats/Time.cc \
         Common/Stats/Time.h \
-        Common/UnimplementedError.h \
         Common/UniqueName.cc \
         Common/UniqueName.h \

src/Common/utility.h

-              r1180175
+              r640b3df
 // file "LICENCE" distributed with Cforall.
 //
 // utility.h --
+// utility.h -- General utilities used across the compiler.
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Mon Apr 25 14:26:00 2022
 // Update Count     : 51
+// Last Modified On : Fri Feb 17 15:25:00 2023
+// Update Count     : 53
 //
 …
 #include <cctype>
 #include <algorithm>
-#include <functional>
 #include <iostream>
-#include <iterator>
 #include <list>
 #include <memory>
 …
 #include <string>
 #include <type_traits>
-#include <utility>
 #include <vector>
 #include <cstring>                                                                              // memcmp
 …
                 return 0;
         } // if
+}
-template< typename T, typename U >
-struct maybeBuild_t {
-        static T * doit( const U *orig ) {
-                if ( orig ) {
-                        return orig->build();
-                } else {
-                        return 0;
-                } // if
+        }
-};
-template< typename T, typename U >
-static inline T * maybeBuild( const U *orig ) {
-        return maybeBuild_t<T,U>::doit(orig);
+}
-template< typename T, typename U >
-static inline T * maybeMoveBuild( const U *orig ) {
-        T* ret = maybeBuild<T>(orig);
-        delete orig;
-        return ret;
+}
 …
 #define toCString( ... ) toString( __VA_ARGS__ ).c_str()
-// replace element of list with all elements of another list
-template< typename T >
-void replace( std::list< T > &org, typename std::list< T >::iterator pos, std::list< T > &with ) {
-        typename std::list< T >::iterator next = pos; advance( next, 1 );
-        //if ( next != org.end() ) {
-        org.erase( pos );
-        org.splice( next, with );
-        //}
-        return;
+}
-// replace range of a list with a single element
-template< typename T >
-void replace( std::list< T > &org, typename std::list< T >::iterator begin, typename std::list< T >::iterator end, const T & with ) {
-        org.insert( begin, with );
-        org.erase( begin, end );
+}
 template< typename... Args >
 …
+}
-template< typename... Args >
-auto zip(Args&&... args) -> decltype(zipWith(std::forward<Args>(args)..., std::make_pair)) {
-  return zipWith(std::forward<Args>(args)..., std::make_pair);
+}
-template< class InputIterator1, class InputIterator2, class OutputIterator, class BinFunction >
-void zipWith( InputIterator1 b1, InputIterator1 e1, InputIterator2 b2, InputIterator2 e2, OutputIterator out, BinFunction func ) {
-        while ( b1 != e1 && b2 != e2 )
-                *out++ = func(*b1++, *b2++);
+}
-// it's nice to actually be able to increment iterators by an arbitrary amount
-template< class InputIt, class Distance >
-InputIt operator+( InputIt it, Distance n ) {
-        advance(it, n);
-        return it;
+}
-template< typename T >
-void warn_single( const T & arg ) {
-        std::cerr << arg << std::endl;
+}
-template< typename T, typename... Params >
-void warn_single(const T & arg, const Params & ... params ) {
-        std::cerr << arg;
-        warn_single( params... );
+}
 template< typename... Params >
 void warn( const Params & ... params ) {
         std::cerr << "Warning: ";
+        warn_single( params... );
+        toString_single( std::cerr, params... );
+        std::cerr << std::endl;
+}
 …
 static inline bool isPrefix( const std::string & str, const std::string & pref, unsigned int start = 0 ) {
         if ( pref.size() > str.size() ) return false;
+    return 0 == memcmp( str.c_str() + start, pref.c_str(), pref.size() );
+        // return prefix == full.substr(0, prefix.size()); // for future, requires c++17
+}
+// -----------------------------------------------------------------------------
+// Ref Counted Singleton class
+// Objects that inherit from this class will have at most one reference to it
+// but if all references die, the object will be deleted.
+template< typename ThisType >
+class RefCountSingleton {
+  public:
+        static std::shared_ptr<ThisType> get() {
+                if( global_instance.expired() ) {
+                        std::shared_ptr<ThisType> new_instance = std::make_shared<ThisType>();
+                        global_instance = new_instance;
+                        return std::move(new_instance);
+                }
+                return global_instance.lock();
+        }
+  private:
+        static std::weak_ptr<ThisType> global_instance;
+};
+template< typename ThisType >
+std::weak_ptr<ThisType> RefCountSingleton<ThisType>::global_instance;
+        return pref == str.substr(start, pref.size());
+}
 // -----------------------------------------------------------------------------
 …
         ~ValueGuardPtr() { if( ref ) { swap( *ref, old ); } }
 };
-// -----------------------------------------------------------------------------
-// Helper struct and function to support
-// for ( val : reverseIterate( container ) ) {}
-// syntax to have a for each that iterates backwards
-template< typename T >
-struct reverse_iterate_t {
-        T& ref;
-        reverse_iterate_t( T & ref ) : ref(ref) {}
-        // this does NOT work on const T!!!
-        // typedef typename T::reverse_iterator iterator;
-        auto begin() { return ref.rbegin(); }
-        auto end() { return ref.rend(); }
-};
-template< typename T >
-reverse_iterate_t< T > reverseIterate( T & ref ) {
-        return reverse_iterate_t< T >( ref );
+}
-template< typename T >
-struct enumerate_t {
-        template<typename val_t>
-        struct value_t {
-                val_t & val;
-                size_t idx;
-        };
-        template< typename iter_t, typename val_t >
-        struct iterator_t {
-                iter_t it;
-                size_t idx;
-                iterator_t( iter_t _it, size_t _idx ) : it(_it), idx(_idx) {}
-                value_t<val_t> operator*() const { return value_t<val_t>{ *it, idx }; }
-                bool operator==(const iterator_t & o) const { return o.it == it; }
-                bool operator!=(const iterator_t & o) const { return o.it != it; }
-                iterator_t & operator++() {
-                        it++;
-                        idx++;
-                        return *this;
+                }
-                using difference_type   = typename std::iterator_traits< iter_t >::difference_type;
-                using value_type        = value_t<val_t>;
-                using pointer           = value_t<val_t> *;
-                using reference         = value_t<val_t> &;
-                using iterator_category = std::forward_iterator_tag;
-        };
-        T & ref;
-        using iterator = iterator_t< typename T::iterator, typename T::value_type >;
-        using const_iterator = iterator_t< typename T::const_iterator, const typename T::value_type >;
-        iterator begin() { return iterator( ref.begin(), 0 ); }
-        iterator end()   { return iterator( ref.end(), ref.size() ); }
-        const_iterator begin() const { return const_iterator( ref.cbegin(), 0 ); }
-        const_iterator end()   const { return const_iterator( ref.cend(), ref.size() ); }
-        const_iterator cbegin() const { return const_iterator( ref.cbegin(), 0 ); }
-        const_iterator cend()   const { return const_iterator( ref.cend(), ref.size() ); }
-};
-template< typename T >
-enumerate_t<T> enumerate( T & ref ) {
-        return enumerate_t< T >{ ref };
+}
-template< typename T >
-const enumerate_t< const T > enumerate( const T & ref ) {
-        return enumerate_t< const T >{ ref };
+}
-template< typename OutType, typename Range, typename Functor >
-OutType map_range( const Range& range, Functor&& functor ) {
-        OutType out;
-        std::transform(
-                begin( range ),
-                end( range ),
-                std::back_inserter( out ),
-                std::forward< Functor >( functor )
-        );
-        return out;
+}
-// -----------------------------------------------------------------------------
-// Helper struct and function to support:
-// for ( auto val : group_iterate( container1, container2, ... ) ) { ... }
-// This iteraters through multiple containers of the same size.
-template<typename... Args>
-class group_iterate_t {
-        using Iterables = std::tuple<Args...>;
-        Iterables iterables;
-        // Getting the iterator and value types this way preserves const.
-        template<size_t I> using Iter = decltype(std::get<I>(iterables).begin());
-        template<size_t I> using Data = decltype(*std::get<I>(iterables).begin());
-        template<typename> struct base_iterator;
-        // This inner template puts the sequence of `0, 1, ... sizeof...(Args)-1`
-        // into a pack. These are the indexes into the tuples, so unpacking can
-        // go over each element of the tuple.
-        // The std::integer_sequence is just used to build that sequence.
-        // A library reference will probably explain it better than I can.
-        template<std::size_t... Indices>
-        struct base_iterator<std::integer_sequence<std::size_t, Indices...>> {
-                using value_type = std::tuple< Data<Indices>... >;
-                std::tuple<Iter<Indices>...> iterators;
-                base_iterator( Iter<Indices>... is ) : iterators( is... ) {}
-                base_iterator operator++() {
-                        return base_iterator( ++std::get<Indices>( iterators )... );
+                }
-                bool operator!=( const base_iterator& other ) const {
-                        return iterators != other.iterators;
+                }
-                value_type operator*() const {
-                        return std::tie( *std::get<Indices>( iterators )... );
+                }
-                static base_iterator make_begin( Iterables & data ) {
-                        return base_iterator( std::get<Indices>( data ).begin()... );
+                }
-                static base_iterator make_end( Iterables & data ) {
-                        return base_iterator( std::get<Indices>( data ).end()... );
+                }
-        };
-public:
-        group_iterate_t( const Args &... args ) : iterables( args... ) {}
-        using iterator = base_iterator<decltype(
-                std::make_integer_sequence<std::size_t, sizeof...(Args)>())>;
-        iterator begin() { return iterator::make_begin( iterables ); }
-        iterator end() { return iterator::make_end( iterables ); }
-};
-// Helpers for the bounds checks (the non-varatic part of group_iterate):
-static inline void runGroupBoundsCheck(size_t size0, size_t size1) {
-        assertf( size0 == size1,
-                "group iteration requires containers of the same size: <%zd, %zd>.",
-                size0, size1 );
+}
-static inline void runGroupBoundsCheck(size_t size0, size_t size1, size_t size2) {
-        assertf( size0 == size1 && size1 == size2,
-                "group iteration requires containers of the same size: <%zd, %zd, %zd>.",
-                size0, size1, size2 );
+}
-/// Performs bounds check to ensure that all arguments are of the same length.
-template< typename... Args >
-group_iterate_t<Args...> group_iterate( Args &&... args ) {
-        runGroupBoundsCheck( args.size()... );
-        return group_iterate_t<Args...>( std::forward<Args>( args )... );
+}
-/// Does not perform a bounds check - requires user to ensure that iteration terminates when appropriate.
-template< typename... Args >
-group_iterate_t<Args...> unsafe_group_iterate( Args &&... args ) {
-        return group_iterate_t<Args...>( std::forward<Args>( args )... );
+}
-// -----------------------------------------------------------------------------
-// Helper struct and function to support
-// for ( val : lazy_map( container1, f ) ) {}
-// syntax to have a for each that iterates a container, mapping each element by applying f
-template< typename T, typename Func >
-struct lambda_iterate_t {
-        const T & ref;
-        std::function<Func> f;
-        struct iterator {
-                typedef decltype(begin(ref)) Iter;
-                Iter it;
-                std::function<Func> f;
-                iterator( Iter it, std::function<Func> f ) : it(it), f(f) {}
-                iterator & operator++() {
-                        ++it; return *this;
+                }
-                bool operator!=( const iterator &other ) const { return it != other.it; }
-                auto operator*() const -> decltype(f(*it)) { return f(*it); }
-        };
-        lambda_iterate_t( const T & ref, std::function<Func> f ) : ref(ref), f(f) {}
-        auto begin() const -> decltype(iterator(std::begin(ref), f)) { return iterator(std::begin(ref), f); }
-        auto end() const   -> decltype(iterator(std::end(ref), f)) { return iterator(std::end(ref), f); }
-};
-template< typename... Args >
-lambda_iterate_t<Args...> lazy_map( const Args &... args ) {
-        return lambda_iterate_t<Args...>( args...);
+}
 // -----------------------------------------------------------------------------
 …
 } // ilog2
-// -----------------------------------------------------------------------------
-/// 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);
-namespace ast {
-        class Expr;
+}
-std::pair<long long int, bool> eval(const ast::Expr * expr);
-// -----------------------------------------------------------------------------
-/// Reorders the input range in-place so that the minimal-value elements according to the
-/// comparator are in front;
-/// returns the iterator after the last minimal-value element.
-template<typename Iter, typename Compare>
-Iter sort_mins( Iter begin, Iter end, Compare& lt ) {
-        if ( begin == end ) return end;
-        Iter min_pos = begin;
-        for ( Iter i = begin + 1; i != end; ++i ) {
-                if ( lt( *i, *min_pos ) ) {
-                        // new minimum cost; swap into first position
-                        min_pos = begin;
-                        std::iter_swap( min_pos, i );
-                } else if ( ! lt( *min_pos, *i ) ) {
-                        // duplicate minimum cost; swap into next minimum position
-                        ++min_pos;
-                        std::iter_swap( min_pos, i );
+                }
+        }
-        return ++min_pos;
+}
-template<typename Iter, typename Compare>
-inline Iter sort_mins( Iter begin, Iter end, Compare&& lt ) {
-        return sort_mins( begin, end, lt );
+}
-/// sort_mins defaulted to use std::less
-template<typename Iter>
-inline Iter sort_mins( Iter begin, Iter end ) {
-        return sort_mins( begin, end, std::less<typename std::iterator_traits<Iter>::value_type>{} );
+}
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/Box.cc

-              r1180175
+              r640b3df
                         CallAdapter();
+                        void premutate( Declaration * declaration );
                         void premutate( FunctionDecl * functionDecl );
                         void premutate( TypeDecl * typeDecl );
 …
                 CallAdapter::CallAdapter() : tempNamer( "_temp" ) {}
+                void CallAdapter::premutate( Declaration * ) {
+                        // Prevent type declaration information from leaking out.
+                        GuardScope( scopeTyVars );
+                }
                 void CallAdapter::premutate( FunctionDecl *functionDecl ) {

src/GenPoly/FindFunction.cc

-              r1180175
+              r640b3df
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Fri Feb 05 12:22:20 2016
 // Update Count     : 6
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Oct  7 17:05:20 2022
+// Update Count     : 7
 //
 …
 #include <utility>                      // for pair
+#include "AST/Pass.hpp"                 // for Pass
+#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"         // for PassVisitor
 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::iterator
 …
                 handleForall( pointerType->get_forall() );
+        }
+namespace {
+struct FindFunctionCore :
+                public ast::WithGuards,
+                public ast::WithShortCircuiting,
+                public ast::WithVisitorRef<FindFunctionCore> {
+        FindFunctionCore(
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate,
+                bool replaceMode );
+        void previsit( ast::FunctionType const * type );
+        ast::Type const * postvisit( ast::FunctionType const * type );
+        void previsit( ast::PointerType const * type );
+private:
+        void handleForall( const ast::FunctionType::ForallList & forall );
+        std::vector<ast::ptr<ast::FunctionType>> &functions;
+        TypeVarMap typeVars;
+        FindFunctionPred predicate;
+        bool replaceMode;
+};
+FindFunctionCore::FindFunctionCore(
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap &typeVars, FindFunctionPred predicate,
+                bool replaceMode ) :
+        functions( functions ), typeVars( typeVars ),
+        predicate( predicate ), replaceMode( replaceMode ) {}
+void FindFunctionCore::handleForall( const ast::FunctionType::ForallList & forall ) {
+        for ( const ast::ptr<ast::TypeInstType> & td : forall ) {
+                TypeVarMap::iterator var = typeVars.find( *td );
+                if ( var != typeVars.end() ) {
+                        typeVars.erase( var->first );
+                } // if
+        } // for
+}
+void FindFunctionCore::previsit( ast::FunctionType const * type ) {
+        visit_children = false;
+        GuardScope( typeVars );
+        handleForall( type->forall );
+        //ast::accept_all( type->returns, *visitor );
+        // This might have to become ast::mutate_each with return.
+        ast::accept_each( type->returns, *visitor );
+}
+ast::Type const * FindFunctionCore::postvisit( ast::FunctionType const * type ) {
+        ast::Type const * ret = type;
+        if ( predicate( type, typeVars ) ) {
+                functions.push_back( type );
+                if ( replaceMode ) {
+                        // replace type parameters in function type with void*
+                        ret = scrubTypeVars( ast::deepCopy( type ), typeVars );
+                } // if
+        } // if
+        return ret;
+}
+void FindFunctionCore::previsit( ast::PointerType const * /*type*/ ) {
+        GuardScope( typeVars );
+        //handleForall( type->forall );
+}
+} // namespace
+void findFunction( const ast::Type * type,
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate ) {
+        ast::Pass<FindFunctionCore> pass( functions, typeVars, predicate, false );
+        type->accept( pass );
+        //(void)type;
+        //(void)functions;
+        //(void)typeVars;
+        //(void)predicate;
+}
+const ast::Type * findAndReplaceFunction( const ast::Type * type,
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate ) {
+        ast::Pass<FindFunctionCore> pass( functions, typeVars, predicate, true );
+        return type->accept( pass );
+        //(void)functions;
+        //(void)typeVars;
+        //(void)predicate;
+        //return type;
+}
 } // namespace GenPoly

src/GenPoly/FindFunction.h

-              r1180175
+              r640b3df
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:23:36 2017
 // Update Count     : 2
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Oct  7 10:30:00 2022
+// Update Count     : 3
 //
 …
         /// like `findFunction`, but also replaces the function type with void ()(void)
         void findAndReplaceFunction( Type *&type, std::list< FunctionType const * > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate );
+typedef bool (*FindFunctionPred)( const ast::FunctionType *, const TypeVarMap & );
+/// Recursively walks `type`, placing all functions that match `predicate`
+/// under `typeVars` into `functions`.
+void findFunction( const ast::Type * type,
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate );
+/// Like findFunction, but also replaces the function type with `void ()(void)`.
+const ast::Type * findAndReplaceFunction( const ast::Type * type,
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate );
 } // namespace GenPoly

src/GenPoly/GenPoly.cc

-              r1180175
+              r640b3df
+        }
+const ast::BaseInstType *isDynRet( const ast::FunctionType * func ) {
+        if ( func->returns.empty() ) return nullptr;
+        TypeVarMap forallTypes = { ast::TypeData() };
+        makeTypeVarMap( func, forallTypes );
+        return isDynType( func->returns.front(), forallTypes );
+}
         bool needsAdapter( FunctionType *adaptee, const TyVarMap &tyVars ) {
 //              if ( ! adaptee->get_returnVals().empty() && isPolyType( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
 …
                 return 0;
+        }
+const ast::Type * isPolyPtr(
+                const ast::Type * type, const TypeVarMap & typeVars,
+                const ast::TypeSubstitution * typeSubs ) {
+        type = replaceTypeInst( type, typeSubs );
+        if ( auto * ptr = dynamic_cast<ast::PointerType const *>( type ) ) {
+                return isPolyType( ptr->base, typeVars, typeSubs );
+        }
+        return nullptr;
+}
         Type * hasPolyBase( Type *type, int *levels, const TypeSubstitution *env ) {
 …
+        }
+void addToTypeVarMap( const ast::TypeDecl * decl, TypeVarMap & typeVars ) {
+        typeVars.insert( ast::TypeEnvKey( decl, 0, 0 ), ast::TypeData( decl ) );
+}
 void addToTypeVarMap( const ast::TypeInstType * type, TypeVarMap & typeVars ) {
         typeVars.insert( *type, ast::TypeData( type->base ) );
+        typeVars.insert( ast::TypeEnvKey( *type ), ast::TypeData( type->base ) );
+}
 …
+}
+void makeTypeVarMap( const ast::FunctionDecl * decl, TypeVarMap & typeVars ) {
+        for ( auto & typeDecl : decl->type_params ) {
+                addToTypeVarMap( typeDecl, typeVars );
+        }
+}
         void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap ) {
                 for ( TyVarMap::const_iterator i = tyVarMap.begin(); i != tyVarMap.end(); ++i ) {

src/GenPoly/GenPoly.h

-              r1180175
+              r640b3df
         void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap );
         void addToTypeVarMap( const ast::TypeDecl * type, TypeVarMap & typeVars );
+        void addToTypeVarMap( const ast::TypeInstType * type, TypeVarMap & typeVars );
         /// Adds the declarations in the forall list of type (and its pointed-to type if it's a pointer type) to `tyVarMap`
         void makeTyVarMap( Type *type, TyVarMap &tyVarMap );
         void makeTypeVarMap( const ast::Type * type, TypeVarMap & typeVars );
+        void makeTypeVarMap( const ast::FunctionDecl * decl, TypeVarMap & typeVars );
         /// Prints type variable map

src/Parser/DeclarationNode.cc

-              r1180175
+              r640b3df
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Aug  8 17:07:00 2022
 // Update Count     : 1185
+// Last Modified On : Thu Feb 16 14:12:03 2023
+// Update Count     : 1388
 //
 …
         variable.initializer = nullptr;
-//      attr.name = nullptr;
-        attr.expr = nullptr;
-        attr.type = nullptr;
         assert.condition = nullptr;
         assert.message = nullptr;
 …
 DeclarationNode::~DeclarationNode() {
-//      delete attr.name;
-        delete attr.expr;
-        delete attr.type;
 //      delete variable.name;
         delete variable.assertions;
 …
         newnode->variable.initializer = maybeClone( variable.initializer );
-//      newnode->attr.name = attr.name ? new string( *attr.name ) : nullptr;
-        newnode->attr.expr = maybeClone( attr.expr );
-        newnode->attr.type = maybeClone( attr.type );
         newnode->assert.condition = maybeClone( assert.condition );
         newnode->assert.message = maybeClone( assert.message );
 …
         } // if
+        for ( Attribute * attr: reverseIterate( attributes ) ) {
+                os << string( indent + 2, ' ' ) << "attr " << attr->name.c_str();
+        } // for
+        if ( ! attributes.empty() ) {
+                os << string( indent + 2, ' ' ) << "with attributes " << endl;
+                for ( Attribute * attr: reverseIterate( attributes ) ) {
+                        os << string( indent + 4, ' ' ) << attr->name.c_str() << endl;
+                } // for
+        } // if
         os << endl;
 …
         newnode->type = new TypeData( TypeData::Aggregate );
         newnode->type->aggregate.kind = kind;
+        newnode->type->aggregate.name = name == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name;
+        newnode->type->aggregate.anon = name == nullptr;
+        newnode->type->aggregate.name = newnode->type->aggregate.anon ? new string( DeclarationNode::anonymous.newName() ) : name;
         newnode->type->aggregate.actuals = actuals;
         newnode->type->aggregate.fields = fields;
 …
         newnode->type->aggregate.tagged = false;
         newnode->type->aggregate.parent = nullptr;
-        newnode->type->aggregate.anon = name == nullptr;
         return newnode;
 } // DeclarationNode::newAggregate
 …
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Enum );
+        newnode->type->enumeration.name = name == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name;
+        newnode->type->enumeration.anon = name == nullptr;
+        newnode->type->enumeration.name = newnode->type->enumeration.anon ? new string( DeclarationNode::anonymous.newName() ) : name;
         newnode->type->enumeration.constants = constants;
         newnode->type->enumeration.body = body;
-        newnode->type->enumeration.anon = name == nullptr;
         newnode->type->enumeration.typed = typed;
         newnode->type->enumeration.hiding = hiding;
 …
         for ( const DeclarationNode * cur = firstNode; cur; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) {
                 try {
+                        bool extracted = false;
+                        bool anon = false;
+                        bool extracted = false, anon = false;
+                        AggregateDecl * unionDecl = nullptr;
                         if ( DeclarationNode * extr = cur->extractAggregate() ) {
                                 // handle the case where a structure declaration is contained within an object or type declaration
                                 Declaration * decl = extr->build();
                                 if ( decl ) {
+                                        // hoist the structure declaration
+                                        // Remember the declaration if it is a union aggregate ?
+                                        unionDecl = dynamic_cast<UnionDecl *>( decl );
                                         decl->location = cur->location;
                                         * out++ = decl;
+                                        *out++ = decl;
                                         // need to remember the cases where a declaration contains an anonymous aggregate definition
 …
                                         assert( extr->type );
                                         if ( extr->type->kind == TypeData::Aggregate ) {
+                                                // typedef struct { int A } B is the only case?
                                                 anon = extr->type->aggregate.anon;
                                         } else if ( extr->type->kind == TypeData::Enum ) {
                                                 // xxx - is it useful to have an implicit anonymous enum member?
+                                                // typedef enum { A } B is the only case?
                                                 anon = extr->type->enumeration.anon;
+                                        }
 …
                         Declaration * decl = cur->build();
                         if ( decl ) {
+                                if ( TypedefDecl * typedefDecl = dynamic_cast<TypedefDecl *>( decl ) ) {
+                                        if ( unionDecl ) {                                      // is the typedef alias a union aggregate ?
+                                                // This code handles a special issue with the attribute transparent_union.
+                                                //
+                                                //    typedef union U { int i; } typedef_name __attribute__(( aligned(16) )) __attribute__(( transparent_union ))
+                                                //
+                                                // Here the attribute aligned goes with the typedef_name, so variables declared of this type are
+                                                // aligned.  However, the attribute transparent_union must be moved from the typedef_name to
+                                                // alias union U.  Currently, this is the only know attribute that must be moved from typedef to
+                                                // alias.
+                                                // If typedef is an alias for a union, then its alias type was hoisted above and remembered.
+                                                if ( UnionInstType * unionInstType = dynamic_cast<UnionInstType *>( typedefDecl->base ) ) {
+                                                        // Remove all transparent_union attributes from typedef and move to alias union.
+                                                        list<Attribute *>::iterator attr;
+                                                        for ( attr = unionInstType->attributes.begin(); attr != unionInstType->attributes.end(); ) { // forward order
+                                                                if ( (*attr)->name == "transparent_union" || (*attr)->name == "__transparent_union__" ) {
+                                                                        list<Attribute *>::iterator cur = attr; // remember current node
+                                                                        attr++;                         // advance iterator
+                                                                        unionDecl->attributes.emplace_back( *cur ); // move current
+                                                                        unionInstType->attributes.erase( cur ); // remove current
+                                                                } else {
+                                                                        attr++;                         // advance iterator
+                                                                } // if
+                                                        } // for
+                                                } // if
+                                        } // if
+                                } // if
                                 // don't include anonymous declaration for named aggregates, but do include them for anonymous aggregates, e.g.:
                                 // struct S {
 …
         assert( type );
-        if ( attr.expr ) {
-                return new AttrType( buildQualifiers( type ), *name, attr.expr->build(), attributes );
-        } else if ( attr.type ) {
-                return new AttrType( buildQualifiers( type ), *name, attr.type->buildType(), attributes );
-        } // if
         switch ( type->kind ) {
           case TypeData::Enum:

src/Parser/ExpressionNode.cc

-              r1180175
+              r640b3df
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Aug  7 09:18:56 2021
 // Update Count     : 1077
+// Last Modified On : Sat Feb 11 14:49:00 2023
+// Update Count     : 1079
 //
 …
                 if ( posn != string::npos ) { Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 ); goto FINI; }
                 posn = str.rfind( "hh" );                                               // char
+                posn = str.rfind( "hh" );                                               // signed char
                 if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
                 posn = str.rfind( "HH" );                                               // char
+                posn = str.rfind( "HH" );                                               // signed char
                 if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
 …
 Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node ) {
         list< Expression * > args;
         args.push_back(  maybeMoveBuild< Expression >(expr_node) ); // xxx -- this is exactly the same as the val case now, refactor this code.
+        args.push_back( maybeMoveBuild< Expression >(expr_node) ); // xxx -- this is exactly the same as the val case now, refactor this code.
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 } // build_unary_ptr

src/Parser/ParseNode.h

-              r1180175
+              r640b3df
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Nov  2 21:27:07 2022
 // Update Count     : 939
+// Last Modified On : Sun Feb 19 09:02:37 2023
+// Update Count     : 940
 //
 …
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/UniqueName.h"     // for UniqueName
+#include "Common/utility.h"        // for maybeClone, maybeBuild
+#include "Common/utility.h"        // for maybeClone
+#include "Parser/parserutility.h"  // for maybeBuild
 #include "SynTree/LinkageSpec.h"   // for Spec
 #include "SynTree/Declaration.h"   // for Aggregate
 …
         Variable_t variable;
-        struct Attr_t {
-//              const std::string * name;
-                ExpressionNode * expr;
-                DeclarationNode * type;
-        };
-        Attr_t attr;
         struct StaticAssert_t {
                 ExpressionNode * condition;
 …
         bool inLine = false;
         bool enumInLine = false;
+        bool enumInLine = false;
         Type::FuncSpecifiers funcSpecs;
         Type::StorageClasses storageClasses;

src/Parser/RunParser.cpp

-              r1180175
+              r640b3df
 // Created On       : Mon Dec 19 11:00:00 2022
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr Dec 22 10:18:00 2022
 // Update Count     : 1
+// Last Modified On : Thr Feb 16 10:08:00 2023
+// Update Count     : 2
 //
 …
 // Variables global to the parsing code.
 LinkageSpec::Spec linkage = LinkageSpec::Cforall;
+ast::Linkage::Spec linkage = ast::Linkage::Cforall;
 TypedefTable typedefTable;
 DeclarationNode * parseTree = nullptr;
 void parse( FILE * input, LinkageSpec::Spec linkage, bool alwaysExit ) {
+void parse( FILE * input, ast::Linkage::Spec linkage, bool alwaysExit ) {
         extern int yyparse( void );
         extern FILE * yyin;

src/Parser/RunParser.hpp

-              r1180175
+              r640b3df
 // Created On       : Mon Dec 19 10:42:00 2022
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr Dec 22 10:23:00 2022
 // Update Count     : 1
+// Last Modified On : Thr Feb 16 10:08:00 2023
+// Update Count     : 2
 //
 …
 #include <iosfwd>                           // for ostream
 #include "SynTree/LinkageSpec.h"            // for Spec
+#include "AST/LinkageSpec.hpp"              // for Spec
 namespace ast {
         class TranslationUnit;
 …
 /// The input file is closed when complete. Exits instead of returning on
 /// error or if alwaysExit is true.
 void parse( FILE * input, LinkageSpec::Spec linkage, bool alwaysExit = false );
+void parse( FILE * input, ast::Linkage::Spec linkage, bool alwaysExit = false );
 /// Drain the internal accumulator of parsed code and build a translation

src/Parser/TypeData.cc

-              r1180175
+              r640b3df
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue May 10 22:36:52 2022
 // Update Count     : 677
+// Last Modified On : Sun Feb 19 11:00:46 2023
+// Update Count     : 679
 //
 …
                 break;
           case Enum:
                 os << "enumeration ";
+                os << "enumeration " << *enumeration.name << endl;;
                 if ( enumeration.constants ) {
                         os << "with constants" << endl;

src/Parser/TypeData.h

-              r1180175
+              r640b3df
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue May 10 22:18:49 2022
 // Update Count     : 203
+// Last Modified On : Sun Feb 19 09:09:39 2023
+// Update Count     : 204
 //
 …
                 bool body;
                 bool anon;
                 bool tagged;
                 const std::string * parent = nullptr;

src/Parser/parser.yy

-              r1180175
+              r640b3df
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Feb  2 21:36:16 2023
 // Update Count     : 5865
+// Last Modified On : Mon Feb 20 11:31:26 2023
+// Update Count     : 5896
 //
 …
 #include "Common/utility.h"                                                             // for maybeMoveBuild, maybeBuild, CodeLo...
 #include "SynTree/Attribute.h"     // for Attribute
+#include "SynTree/Attribute.h"                                                  // for Attribute
 // lex uses __null in a boolean context, it's fine.
 …
+                {
                         typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "6" );
                         $$ = $4->addType( $3 )->addQualifiers( $1 )->addTypedef();
+                        $$ = $4->addQualifiers( $1 )->addType( $3 )->addTypedef();
+                }
         | type_specifier TYPEDEF declarator
 …
+                {
                         typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "8" );
                         $$ = $4->addQualifiers( $1 )->addTypedef()->addType( $1 );
+                        $$ = $4->addQualifiers( $1 )->addType( $1 )->addTypedef();
+                }
+        ;
 …
         | typedef_expression                                                            // deprecated GCC, naming expression type
         | sue_declaration_specifier
+                {
+                        assert( $1->type );
+                        if ( $1->type->qualifiers.val != 0 ) {
+                                SemanticError( yylloc, "Useless type qualifier in empty declaration." ); $$ = nullptr;
+                        }
+                }
+        ;

src/Parser/parserutility.h

-              r1180175
+              r640b3df
 // file "LICENCE" distributed with Cforall.
 //
 // parserutility.h --
+// parserutility.h -- Collected utilities for the parser.
 //
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 15:31:46 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:32:58 2017
 // Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Feb 16 12:34:00 2023
+// Update Count     : 5
 //
 …
 Expression *notZeroExpr( Expression *orig );
+template< typename T, typename U >
+struct maybeBuild_t {
+        static T * doit( const U *orig ) {
+                if ( orig ) {
+                        return orig->build();
+                } else {
+                        return 0;
+                }
+        }
+};
+template< typename T, typename U >
+static inline T * maybeBuild( const U *orig ) {
+        return maybeBuild_t<T,U>::doit(orig);
+}
+template< typename T, typename U >
+static inline T * maybeMoveBuild( const U *orig ) {
+        T* ret = maybeBuild<T>(orig);
+        delete orig;
+        return ret;
+}
 // Local Variables: //
 // tab-width: 4 //

src/ResolvExpr/CurrentObject.cc

-              r1180175
+              r640b3df
 #include "AST/Init.hpp"                // for Designation
 #include "AST/Node.hpp"                // for readonly
 #include "AST/Print.hpp"                // for readonly
+#include "AST/Print.hpp"               // for readonly
 #include "AST/Type.hpp"
+#include "Common/Eval.h"               // for eval
 #include "Common/Indenter.h"           // for Indenter, operator<<
 #include "Common/SemanticError.h"      // for SemanticError

src/ResolvExpr/ResolveAssertions.cc

r1180175	r640b3df
30	30	#include "Common/FilterCombos.h" // for filterCombos
31	31	#include "Common/Indenter.h" // for Indenter
32		~~#include "Common/utility.h" // for sort_mins~~
33	32	#include "GenPoly/GenPoly.h" // for getFunctionType
34	33	#include "ResolvExpr/AlternativeFinder.h" // for computeConversionCost

src/ResolvExpr/Resolver.cc

r1180175	r640b3df
38	38	#include "AST/SymbolTable.hpp"
39	39	#include "AST/Type.hpp"
	40	#include "Common/Eval.h" // for eval
40	41	#include "Common/PassVisitor.h" // for PassVisitor
41	42	#include "Common/SemanticError.h" // for SemanticError

src/ResolvExpr/Resolver.h

r1180175	r640b3df
34	34	class Decl;
35	35	class DeletedExpr;
	36	class Expr;
36	37	class Init;
37	38	class StmtExpr;

src/SynTree/AggregateDecl.cc

r1180175	r640b3df
19	19
20	20	#include "Attribute.h" // for Attribute
	21	#include "Common/Eval.h" // for eval
21	22	#include "Common/utility.h" // for printAll, cloneAll, deleteAll
22	23	#include "Declaration.h" // for AggregateDecl, TypeDecl, Declaration

src/SynTree/Type.h

-              r1180175
+              r640b3df
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Jul 14 15:40:00 2021
 // Update Count     : 171
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun Feb 19 22:37:10 2023
+// Update Count     : 176
 //
 …
 #include "BaseSyntaxNode.h"  // for BaseSyntaxNode
+#include "Common/utility.h"  // for operator+
+#include "Common/Iterate.hpp"// for operator+
+#include "Common/utility.h"  // for toCString
 #include "Mutator.h"         // for Mutator
 #include "SynTree.h"         // for AST nodes
 …
                 bool operator!=( Qualifiers other ) const { return (val & Mask) != (other.val & Mask); }
                 bool operator<=( Qualifiers other ) const {
                         return is_const    <= other.is_const        //Any non-const converts to const without cost
                                         && is_volatile <= other.is_volatile     //Any non-volatile converts to volatile without cost
                                         && is_mutex    >= other.is_mutex        //Any mutex converts to non-mutex without cost
                                         && is_atomic   == other.is_atomic;      //No conversion from atomic to non atomic is free
+                        return is_const    <= other.is_const        // Any non-const converts to const without cost
+                                && is_volatile <= other.is_volatile             // Any non-volatile converts to volatile without cost
+                                && is_mutex    >= other.is_mutex                // Any mutex converts to non-mutex without cost
+                                && is_atomic   == other.is_atomic;              // No conversion from atomic to non atomic is free
+                }
                 bool operator<( Qualifiers other ) const { return *this != other && *this <= other; }
 …
         virtual TypeSubstitution genericSubstitution() const;
         virtual Type *clone() const = 0;
+        virtual Type * clone() const = 0;
         virtual void accept( Visitor & v ) = 0;
         virtual void accept( Visitor & v ) const = 0;
         virtual Type *acceptMutator( Mutator & m ) = 0;
+        virtual Type * acceptMutator( Mutator & m ) = 0;
         virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual bool isComplete() const override { return false; }
         virtual VoidType *clone() const override { return new VoidType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual VoidType * clone() const override { return new VoidType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         // GENERATED END
         static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
+        static const char * typeNames[];                                        // string names for basic types, MUST MATCH with Kind
         BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
 …
         void set_kind( Kind newValue ) { kind = newValue; }
         virtual BasicType *clone() const override { return new BasicType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual BasicType * clone() const override { return new BasicType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
         bool isInteger() const;
 …
         // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
         Expression *dimension;
+        Expression * dimension;
         bool isVarLen;
         bool isStatic;
         PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        PointerType( const Type::Qualifiers & tq, Type * base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        PointerType( const Type::Qualifiers & tq, Type * base, Expression * dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         PointerType( const PointerType& );
         virtual ~PointerType();
         Type *get_base() { return base; }
         void set_base( Type *newValue ) { base = newValue; }
         Expression *get_dimension() { return dimension; }
         void set_dimension( Expression *newValue ) { dimension = newValue; }
+        Type * get_base() { return base; }
+        void set_base( Type * newValue ) { base = newValue; }
+        Expression * get_dimension() { return dimension; }
+        void set_dimension( Expression * newValue ) { dimension = newValue; }
         bool get_isVarLen() { return isVarLen; }
         void set_isVarLen( bool newValue ) { isVarLen = newValue; }
 …
         virtual bool isComplete() const override { return ! isVarLen; }
         virtual PointerType *clone() const override { return new PointerType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual PointerType * clone() const override { return new PointerType( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
 class ArrayType : public Type {
   public:
         Type *base;
         Expression *dimension;
+        Type * base;
+        Expression * dimension;
         bool isVarLen;
         bool isStatic;
         ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        ArrayType( const Type::Qualifiers & tq, Type * base, Expression * dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         ArrayType( const ArrayType& );
         virtual ~ArrayType();
         Type *get_base() { return base; }
         void set_base( Type *newValue ) { base = newValue; }
         Expression *get_dimension() { return dimension; }
         void set_dimension( Expression *newValue ) { dimension = newValue; }
+        Type * get_base() { return base; }
+        void set_base( Type * newValue ) { base = newValue; }
+        Expression * get_dimension() { return dimension; }
+        void set_dimension( Expression * newValue ) { dimension = newValue; }
         bool get_isVarLen() { return isVarLen; }
         void set_isVarLen( bool newValue ) { isVarLen = newValue; }
 …
         virtual bool isComplete() const override { return dimension || isVarLen; }
         virtual ArrayType *clone() const override { return new ArrayType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual ArrayType * clone() const override { return new ArrayType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         virtual ~QualifiedType();
         virtual QualifiedType *clone() const override { return new QualifiedType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual QualifiedType * clone() const override { return new QualifiedType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
 class ReferenceType : public Type {
 public:
         Type *base;
         ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        Type * base;
+        ReferenceType( const Type::Qualifiers & tq, Type * base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         ReferenceType( const ReferenceType & );
         virtual ~ReferenceType();
         Type *get_base() { return base; }
         void set_base( Type *newValue ) { base = newValue; }
+        Type * get_base() { return base; }
+        void set_base( Type * newValue ) { base = newValue; }
         virtual int referenceDepth() const override;
 …
         virtual TypeSubstitution genericSubstitution() const override;
         virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual ReferenceType * clone() const override { return new ReferenceType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
         virtual FunctionType *clone() const override { return new FunctionType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual FunctionType * clone() const override { return new FunctionType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
 class ReferenceToType : public Type {
   public:
         std::list< Expression* > parameters;
+        std::list< Expression * > parameters;
         std::string name;
         bool hoistType;
 …
         void set_hoistType( bool newValue ) { hoistType = newValue; }
         virtual ReferenceToType *clone() const override = 0;
+        virtual ReferenceToType * clone() const override = 0;
         virtual void accept( Visitor & v ) override = 0;
         virtual Type *acceptMutator( Mutator & m ) override = 0;
+        virtual Type * acceptMutator( Mutator & m ) override = 0;
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 …
         // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
         // where the structure used in this type is actually defined
         StructDecl *baseStruct;
+        StructDecl * baseStruct;
         StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
 …
         StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
         StructDecl *get_baseStruct() const { return baseStruct; }
         void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
+        StructDecl * get_baseStruct() const { return baseStruct; }
+        void set_baseStruct( StructDecl * newValue ) { baseStruct = newValue; }
         /// Accesses generic parameters of base struct (NULL if none such)
 …
         void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
         virtual StructInstType *clone() const override { return new StructInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual StructInstType * clone() const override { return new StructInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 …
         // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
         // where the union used in this type is actually defined
         UnionDecl *baseUnion;
+        UnionDecl * baseUnion;
         UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
 …
         UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
         UnionDecl *get_baseUnion() const { return baseUnion; }
+        UnionDecl * get_baseUnion() const { return baseUnion; }
         void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
 …
         void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
         virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual UnionInstType * clone() const override { return new UnionInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 …
         // this decl is not "owned" by the enum inst; it is merely a pointer to elsewhere in the tree,
         // where the enum used in this type is actually defined
         EnumDecl *baseEnum = nullptr;
+        EnumDecl * baseEnum = nullptr;
         EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
 …
         EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
         EnumDecl *get_baseEnum() const { return baseEnum; }
         void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
+        EnumDecl * get_baseEnum() const { return baseEnum; }
+        void set_baseEnum( EnumDecl * newValue ) { baseEnum = newValue; }
         virtual bool isComplete() const override;
 …
         virtual AggregateDecl * getAggr() const override;
         virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual EnumInstType * clone() const override { return new EnumInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 …
         virtual bool isComplete() const override;
         virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual TraitInstType * clone() const override { return new TraitInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
   private:
         virtual std::string typeString() const override;
 …
         // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
         // where the type used here is actually defined
         TypeDecl *baseType;
+        TypeDecl * baseType;
         bool isFtype;
         TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl * baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TypeInstType( const TypeInstType & other );
         ~TypeInstType();
         TypeDecl *get_baseType() const { return baseType; }
         void set_baseType( TypeDecl *newValue );
+        TypeDecl * get_baseType() const { return baseType; }
+        void set_baseType( TypeDecl * newValue );
         bool get_isFtype() const { return isFtype; }
         void set_isFtype( bool newValue ) { isFtype = newValue; }
 …
         virtual bool isComplete() const override;
         virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual TypeInstType * clone() const override { return new TypeInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
   private:
 …
         // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
         virtual TupleType *clone() const override { return new TupleType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual TupleType * clone() const override { return new TupleType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
 class TypeofType : public Type {
   public:
         Expression *expr;    ///< expression to take the type of
         bool is_basetypeof;  ///< true iff is basetypeof type
         TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof,
+        Expression * expr;              ///< expression to take the type of
+        bool is_basetypeof;             ///< true iff is basetypeof type
+        TypeofType( const Type::Qualifiers & tq, Expression * expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        TypeofType( const Type::Qualifiers & tq, Expression * expr, bool is_basetypeof,
                 const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         TypeofType( const TypeofType& );
         virtual ~TypeofType();
         Expression *get_expr() const { return expr; }
         void set_expr( Expression *newValue ) { expr = newValue; }
+        Expression * get_expr() const { return expr; }
+        void set_expr( Expression * newValue ) { expr = newValue; }
         virtual bool isComplete() const override { assert( false ); return false; }
         virtual TypeofType *clone() const override { return new TypeofType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual TypeofType * clone() const override { return new TypeofType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
 class VTableType : public Type {
 public:
         Type *base;
         VTableType( const Type::Qualifiers & tq, Type *base,
+        Type * base;
+        VTableType( const Type::Qualifiers & tq, Type * base,
                 const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         VTableType( const VTableType & );
         virtual ~VTableType();
         Type *get_base() { return base; }
         void set_base( Type *newValue ) { base = newValue; }
         virtual VTableType *clone() const override { return new VTableType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        Type * get_base() { return base; }
+        void set_base( Type * newValue ) { base = newValue; }
+        virtual VTableType * clone() const override { return new VTableType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
   public:
         std::string name;
         Expression *expr;
         Type *type;
+        Expression * expr;
+        Type * type;
         bool isType;
         AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        AttrType( const Type::Qualifiers & tq, const std::string & name, Expression * expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        AttrType( const Type::Qualifiers & tq, const std::string & name, Type * type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         AttrType( const AttrType& );
         virtual ~AttrType();
 …
         const std::string & get_name() const { return name; }
         void set_name( const std::string & newValue ) { name = newValue; }
         Expression *get_expr() const { return expr; }
         void set_expr( Expression *newValue ) { expr = newValue; }
         Type *get_type() const { return type; }
         void set_type( Type *newValue ) { type = newValue; }
+        Expression * get_expr() const { return expr; }
+        void set_expr( Expression * newValue ) { expr = newValue; }
+        Type * get_type() const { return type; }
+        void set_type( Type * newValue ) { type = newValue; }
         bool get_isType() const { return isType; }
         void set_isType( bool newValue ) { isType = newValue; }
 …
         virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
         virtual AttrType *clone() const override { return new AttrType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual AttrType * clone() const override { return new AttrType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         virtual bool isComplete() const override{ return true; } // xxx - is this right?
         virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual VarArgsType * clone() const override { return new VarArgsType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         virtual ZeroType *clone() const override { return new ZeroType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual ZeroType * clone() const override { return new ZeroType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         virtual OneType *clone() const override { return new OneType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual OneType * clone() const override { return new OneType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         GlobalScopeType();
         virtual GlobalScopeType *clone() const override { return new GlobalScopeType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual GlobalScopeType * clone() const override { return new GlobalScopeType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };

src/Validate/HandleAttributes.cc

r1180175	r640b3df
17	17
18	18	#include "CompilationState.h"
	19	#include "Common/Eval.h"
19	20	#include "Common/PassVisitor.h"
20	21	#include "Common/SemanticError.h"

src/main.cc

-              r1180175
+              r640b3df
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Oct  5 12:06:00 2022
 // Update Count     : 679
+// Last Modified On : Thr Feb 16 10:08:00 2023
+// Update Count     : 680
 //
 …
 #include "CodeTools/TrackLoc.h"             // for fillLocations
 #include "Common/CodeLocationTools.hpp"     // for forceFillCodeLocations
-#include "Common/CompilerError.h"           // for CompilerError
 #include "Common/DeclStats.hpp"             // for printDeclStats
 #include "Common/ResolvProtoDump.hpp"       // for dumpAsResolverProto
 #include "Common/Stats.h"                   // for Stats
-#include "Common/UnimplementedError.h"      // for UnimplementedError
 #include "Common/utility.h"                 // for deleteAll, filter, printAll
 #include "Concurrency/Actors.hpp"           // for implementActors
 …
                         FILE * gcc_builtins = fopen( (PreludeDirector + "/gcc-builtins.cf").c_str(), "r" );
                         assertf( gcc_builtins, "cannot open gcc-builtins.cf\n" );
                         parse( gcc_builtins, LinkageSpec::Compiler );
+                        parse( gcc_builtins, ast::Linkage::Compiler );
                         // read the extra prelude in, if not generating the cfa library
                         FILE * extras = fopen( (PreludeDirector + "/extras.cf").c_str(), "r" );
                         assertf( extras, "cannot open extras.cf\n" );
                         parse( extras, LinkageSpec::BuiltinC );
+                        parse( extras, ast::Linkage::BuiltinC );
                         if ( ! libcfap ) {
 …
                                 FILE * prelude = fopen( (PreludeDirector + "/prelude.cfa").c_str(), "r" );
                                 assertf( prelude, "cannot open prelude.cfa\n" );
                                 parse( prelude, LinkageSpec::Intrinsic );
+                                parse( prelude, ast::Linkage::Intrinsic );
                                 // Read to cfa builtins, if not generating the cfa library
                                 FILE * builtins = fopen( (PreludeDirector + "/builtins.cf").c_str(), "r" );
                                 assertf( builtins, "cannot open builtins.cf\n" );
                                 parse( builtins, LinkageSpec::BuiltinCFA );
                         } // if
                 } // if
                 parse( input, libcfap ? LinkageSpec::Intrinsic : LinkageSpec::Cforall, yydebug );
+                                parse( builtins, ast::Linkage::BuiltinCFA );
+                        } // if
+                } // if
+                parse( input, libcfap ? ast::Linkage::Intrinsic : ast::Linkage::Cforall, yydebug );
                 transUnit = buildUnit();
 …
                 PASS( "Generate Autogen Routines", Validate::autogenerateRoutines( transUnit ) );
+        PASS( "Implement Actors", Concurrency::implementActors( transUnit ) );
+                PASS( "Implement Actors", Concurrency::implementActors( transUnit ) );
                 PASS( "Implement Mutex", Concurrency::implementMutex( transUnit ) );
                 PASS( "Implement Thread Start", Concurrency::implementThreadStarter( transUnit ) );
 …
                 } // if
                 e.print();
-                if ( output != &cout ) {
-                        delete output;
-                } // if
-                return EXIT_FAILURE;
-        } catch ( UnimplementedError & e ) {
-                cout << "Sorry, " << e.get_what() << " is not currently implemented" << endl;
-                if ( output != &cout ) {
-                        delete output;
-                } // if
-                return EXIT_FAILURE;
-        } catch ( CompilerError & e ) {
-                cerr << "Compiler Error: " << e.get_what() << endl;
-                cerr << "(please report bugs to [REDACTED])" << endl;
                 if ( output != &cout ) {
                         delete output;

Context Navigation

Legend:

src/AST/Create.cpp

src/AST/Decl.cpp

src/AST/Pass.impl.hpp

src/AST/Pass.proto.hpp

src/AST/porting.md

src/Common/Eval.cc

src/Common/module.mk

src/Common/utility.h

src/GenPoly/Box.cc

src/GenPoly/FindFunction.cc

src/GenPoly/FindFunction.h

src/GenPoly/GenPoly.cc

src/GenPoly/GenPoly.h

src/Parser/DeclarationNode.cc

src/Parser/ExpressionNode.cc

src/Parser/ParseNode.h

src/Parser/RunParser.cpp

src/Parser/RunParser.hpp

src/Parser/TypeData.cc

src/Parser/TypeData.h

src/Parser/parser.yy

src/Parser/parserutility.h

src/ResolvExpr/CurrentObject.cc

src/ResolvExpr/ResolveAssertions.cc

src/ResolvExpr/Resolver.cc

src/ResolvExpr/Resolver.h

src/SynTree/AggregateDecl.cc

src/SynTree/Type.h

src/Validate/HandleAttributes.cc

src/main.cc

Download in other formats: