Changeset cc7bbe6 for src/AST

Timestamp:

Feb 23, 2022, 11:24:34 AM (4 years ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

ADT, ast-experimental, enum, master, pthread-emulation, qualifiedEnum, stuck-waitfor-destruct

Children:

08ed947

Parents:

f5a51db (diff), 3a038fa (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/AST

Files:

• AssertAcyclic.cpp (deleted)
• AssertAcyclic.hpp (deleted)
• Convert.hpp (modified) (1 diff)
• Decl.cpp (modified) (1 diff)
• Fwd.hpp (modified) (1 diff)
• Pass.hpp (modified) (1 diff)
• Pass.impl.hpp (modified) (13 diffs)
• Pass.proto.hpp (modified) (2 diffs)
• TranslationUnit.hpp (modified) (1 diff)
• Util.cpp (added)
• Util.hpp (added)
• module.mk (modified) (2 diffs)

src/AST/Convert.hpp

@@ -20 +20 @@
 class Declaration;
 namespace ast {
-        struct TranslationUnit;
+        class TranslationUnit;
 };
 

src/AST/Decl.cpp

@@ -39 +39 @@
         if ( uniqueId ) return;  // ensure only set once
         uniqueId = ++lastUniqueId;
-        idMap[ uniqueId ] = this;
+        // The extra readonly pointer is causing some reference counting issues.
+        // idMap[ uniqueId ] = this;
 }
 
 readonly<Decl> Decl::fromId( UniqueId id ) {
+        // Right now this map is always empty, so don't use it.
+        assert( false );
         IdMapType::const_iterator i = idMap.find( id );
         if ( i != idMap.end() ) return i->second;

src/AST/Fwd.hpp

@@ -140 +140 @@
 typedef unsigned int UniqueId;
 
-struct TranslationUnit;
+class TranslationUnit;
 // TODO: Get from the TranslationUnit:
 extern ptr<Type> sizeType;

src/AST/Pass.hpp

@@ -239 +239 @@
 private:
 
-        // Regular nodes
+        __pass::result1<ast::Stmt> call_accept( const ast::Stmt * );
+        __pass::result1<ast::Expr> call_accept( const ast::Expr * );
+
+        /// This has a `type` member that is the return type for the
+        /// generic call_accept if the generic call_accept is defined.
         template< typename node_t >
-        struct result1 {
-                bool differs;
-                const node_t * value;
-
-                template< typename object_t, typename super_t, typename field_t >
-                void apply(object_t *, field_t super_t::* field);
-        };
-
-        result1<ast::Stmt> call_accept( const ast::Stmt * );
-        result1<ast::Expr> call_accept( const ast::Expr * );
+        using generic_call_accept_result =
+                std::enable_if<
+                                !std::is_base_of<ast::Expr, node_t>::value &&
+                                !std::is_base_of<ast::Stmt, node_t>::value
+                        , __pass::result1<
+                                typename std::remove_pointer< typename std::result_of<
+                                        decltype(&node_t::accept)(node_t*, type&) >::type >::type
+                        >
+                >;
 
         template< typename node_t >
         auto call_accept( const node_t * node )
-                -> typename std::enable_if<
-                                !std::is_base_of<ast::Expr, node_t>::value &&
-                                !std::is_base_of<ast::Stmt, node_t>::value
-                        , result1<
-                                typename std::remove_pointer< decltype( node->accept(*this) ) >::type
-                        >
-                >::type;
+                -> typename generic_call_accept_result<node_t>::type;
 
         // requests WithStmtsToAdd directly add to this statement, as if it is a compound.
-        result1<ast::Stmt> call_accept_as_compound(const ast::Stmt *);
-
-        template<typename it_t, template <class...> class container_t>
-                static inline void take_all_delta( it_t it, container_t<ast::ptr<ast::Decl>> * decls, bool * mutated = nullptr ) {
-                        if(empty(decls)) return;
-
-                        std::transform(decls->begin(), decls->end(), it, [](ast::ptr<ast::Decl>&& decl) -> auto {
-                                        auto loc = decl->location;
-                                        auto stmt = new DeclStmt( loc, decl.release() );
-                                        return { {stmt}, -1, false };
-                                });
-                        decls->clear();
-                        if(mutated) *mutated = true;
-                }
-
-        // Container of statements
+        __pass::result1<ast::Stmt> call_accept_as_compound(const ast::Stmt *);
+
         template< template <class...> class container_t >
-        struct resultNstmt {
-                struct delta {
-                        ptr<Stmt> nval;
-                        ssize_t old_idx;
-                        bool is_old;
-
-                        delta(const Stmt * s, ssize_t i, bool old) : nval{s}, old_idx{i}, is_old{old} {}
-                };
-
-                bool differs;
-                container_t< delta > values;
-
-                resultNstmt() : differs(false), values{} {}
-                resultNstmt(bool diff, container_t< delta > && vals) : differs(diff), values(vals) {}
-
-                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<ast::ptr<ast::Stmt>> * stmts ) {
-                        if(!stmts || stmts->empty()) return;
-
-                        std::transform(stmts->begin(), stmts->end(), std::back_inserter( values ), [](ast::ptr<ast::Stmt>& decl) -> delta {
-                                        return delta( decl.release(), -1, false );
-                                });
-                        stmts->clear();
-                        differs = true;
-                }
-
-                template< template <class...> class incontainer_t >
-                void take_all( incontainer_t<ast::ptr<ast::Decl>> * decls ) {
-                        if(!decls || decls->empty()) return;
-
-                        std::transform(decls->begin(), decls->end(), std::back_inserter( values ), [](ast::ptr<ast::Decl>& decl) -> auto {
-                                        auto loc = decl->location;
-                                        auto stmt = new DeclStmt( loc, decl.release() );
-                                        return delta( stmt, -1, false );
-                                });
-                        decls->clear();
-                        differs = true;
-                }
-        };
-
-        template< template <class...> class container_t >
-        resultNstmt<container_t> call_accept( const container_t< ptr<Stmt> > & );
-
-        // Container of something
+        __pass::resultNstmt<container_t> call_accept( const container_t< ptr<Stmt> > & );
+
         template< template <class...> class container_t, typename node_t >
-        struct resultN {
-                bool differs;
-                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);
-        };
-
-        template< template <class...> class container_t, typename node_t >
-        resultN< container_t, node_t > call_accept( const container_t< ptr<node_t> > & container );
+        __pass::resultN< container_t, node_t > call_accept( const container_t< ptr<node_t> > & container );
 
 public:

src/AST/Pass.impl.hpp

@@ -111 +111 @@
                 }
 
-
                 //------------------------------
                 /// Check if value was mutated, different for pointers and containers
@@ -125 +124 @@
         }
 
-
-        template< typename core_t >
         template< typename node_t >
         template< typename object_t, typename super_t, typename field_t >
-        void ast::Pass< core_t >::result1< node_t >::apply(object_t * object, field_t super_t::* field) {
+        void __pass::result1< node_t >::apply( object_t * object, field_t super_t::* field ) {
                 object->*field = value;
         }
@@ -136 +133 @@
         template< typename node_t >
         auto ast::Pass< core_t >::call_accept( const node_t * node )
-                -> typename std::enable_if<
-                                !std::is_base_of<ast::Expr, node_t>::value &&
-                                !std::is_base_of<ast::Stmt, node_t>::value
-                        , ast::Pass< core_t >::result1<
-                                typename std::remove_pointer< decltype( node->accept(*this) ) >::type
-                        >
-                >::type
+                -> typename ast::Pass< core_t >::template generic_call_accept_result<node_t>::type
         {
                 __pedantic_pass_assert( __visit_children() );
@@ -151 +142 @@
 
                 auto nval = node->accept( *this );
-                ast::Pass< core_t >::result1<
+                __pass::result1<
                         typename std::remove_pointer< decltype( node->accept(*this) ) >::type
                 > res;
@@ -160 +151 @@
 
         template< typename core_t >
-        ast::Pass< core_t >::result1<ast::Expr> ast::Pass< core_t >::call_accept( const ast::Expr * expr ) {
+        __pass::template result1<ast::Expr> ast::Pass< core_t >::call_accept( const ast::Expr * expr ) {
                 __pedantic_pass_assert( __visit_children() );
                 __pedantic_pass_assert( expr );
@@ -174 +165 @@
 
         template< typename core_t >
-        ast::Pass< core_t >::result1<ast::Stmt> ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) {
+        __pass::template result1<ast::Stmt> ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) {
                 __pedantic_pass_assert( __visit_children() );
                 __pedantic_pass_assert( stmt );
@@ -183 +174 @@
 
         template< typename core_t >
-        ast::Pass< core_t >::result1<ast::Stmt> ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
+        __pass::template result1<ast::Stmt> ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
                 __pedantic_pass_assert( __visit_children() );
                 __pedantic_pass_assert( stmt );
@@ -233 +224 @@
         }
 
-        template< typename core_t >
         template< template <class...> class container_t >
         template< typename object_t, typename super_t, typename field_t >
-        void ast::Pass< core_t >::resultNstmt<container_t>::apply(object_t * object, field_t super_t::* field) {
+        void __pass::resultNstmt<container_t>::apply(object_t * object, field_t super_t::* field) {
                 auto & container = object->*field;
                 __pedantic_pass_assert( container.size() <= values.size() );
@@ -243 +233 @@
 
                 container_t<ptr<Stmt>> nvals;
-                for(delta & d : values) {
-                        if( d.is_old ) {
+                for (delta & d : values) {
+                        if ( d.is_old ) {
                                 __pedantic_pass_assert( cit.idx <= d.old_idx );
                                 std::advance( cit, d.old_idx - cit.idx );
                                 nvals.push_back( std::move( (*cit).val) );
                         } else {
-                                nvals.push_back( std::move(d.nval) );
+                                nvals.push_back( std::move(d.new_val) );
                         }
                 }
 
-                object->*field = std::move(nvals);
+                container = std::move(nvals);
+        }
+
+        template< template <class...> class container_t >
+        template< template <class...> class incontainer_t >
+        void __pass::resultNstmt< container_t >::take_all( incontainer_t<ptr<Stmt>> * stmts ) {
+                if (!stmts || stmts->empty()) return;
+
+                std::transform(stmts->begin(), stmts->end(), std::back_inserter( values ),
+                        [](ast::ptr<ast::Stmt>& stmt) -> delta {
+                                return delta( stmt.release(), -1, false );
+                        });
+                stmts->clear();
+                differs = true;
+        }
+
+        template< template<class...> class container_t >
+        template< template<class...> class incontainer_t >
+        void __pass::resultNstmt< container_t >::take_all( incontainer_t<ptr<Decl>> * decls ) {
+                if (!decls || decls->empty()) return;
+
+                std::transform(decls->begin(), decls->end(), std::back_inserter( values ),
+                        [](ast::ptr<ast::Decl>& decl) -> delta {
+                                auto loc = decl->location;
+                                auto stmt = new DeclStmt( loc, decl.release() );
+                                return delta( stmt, -1, false );
+                        });
+                decls->clear();
+                differs = true;
         }
 
         template< typename core_t >
         template< template <class...> class container_t >
-        ast::Pass< core_t >::resultNstmt<container_t> ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
+        __pass::template resultNstmt<container_t> ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
                 __pedantic_pass_assert( __visit_children() );
                 if( statements.empty() ) return {};
@@ -285 +303 @@
                 pass_visitor_stats.avg->push(pass_visitor_stats.depth);
 
-                resultNstmt<container_t> new_kids;
+                __pass::resultNstmt<container_t> new_kids;
                 for( auto value : enumerate( statements ) ) {
                         try {
@@ -327 +345 @@
         }
 
-        template< typename core_t >
         template< template <class...> class container_t, typename node_t >
         template< typename object_t, typename super_t, typename field_t >
-        void ast::Pass< core_t >::resultN<container_t, node_t>::apply(object_t * object, field_t super_t::* field) {
+        void __pass::resultN<container_t, node_t>::apply(object_t * object, field_t super_t::* field) {
                 auto & container = object->*field;
                 __pedantic_pass_assert( container.size() == values.size() );
@@ -346 +363 @@
         template< typename core_t >
         template< template <class...> class container_t, typename node_t >
-        ast::Pass< core_t >::resultN<container_t, node_t> ast::Pass< core_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
+        __pass::template resultN<container_t, node_t> ast::Pass< core_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
                 __pedantic_pass_assert( __visit_children() );
                 if( container.empty() ) return {};
@@ -378 +395 @@
                 if ( ! errors.isEmpty() ) { throw errors; }
 
-                return ast::Pass< core_t >::resultN<container_t, node_t>{ mutated,  new_kids };
+                return ast::__pass::resultN<container_t, node_t>{ mutated, new_kids };
         }
 

src/AST/Pass.proto.hpp

@@ -23 +23 @@
 class Pass;
 
-struct TranslationUnit;
+class TranslationUnit;
 
 struct PureVisitor;
@@ -123 +123 @@
                 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;
+                const node_t * value;
+
+                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;
+                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;
+                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 );
         };
 

src/AST/TranslationUnit.hpp

@@ -23 +23 @@
 namespace ast {
 
-struct TranslationUnit {
+class TranslationUnit {
+public:
         std::list< ptr< Decl > > decls;
 

src/AST/module.mk

@@ -16 +16 @@
 
 SRC_AST = \
-        AST/AssertAcyclic.cpp \
-        AST/AssertAcyclic.hpp \
         AST/Attribute.cpp \
         AST/Attribute.hpp \
@@ -64 +62 @@
         AST/TypeSubstitution.cpp \
         AST/TypeSubstitution.hpp \
+        AST/Util.cpp \
+        AST/Util.hpp \
         AST/Visitor.hpp