Changeset e0115286 for src/AST/Decl.hpp

Timestamp:

May 10, 2019, 3:00:41 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

2a5e8a6

Parents:

1f93c2c

Message:

Fix a cyclic dependency with ptr and nodes

File:

• src/AST/Decl.hpp (modified) (5 diffs)

src/AST/Decl.hpp

@@ -122 +122 @@
         std::vector<ptr<DeclWithType>> assertions;
 
-        NamedTypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage, 
+        NamedTypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage,
                 Type* b, Linkage::Spec spec = Linkage::Cforall )
         : Decl( loc, name, storage, spec ), base( b ), parameters(), assertions() {}
@@ -149 +149 @@
                 Data( TypeDecl* d ) : kind( d->kind ), isComplete( d->sized ) {}
                 Data( Kind k, bool c ) : kind( k ), isComplete( c ) {}
-                Data( const Data& d1, const Data& d2 ) 
+                Data( const Data& d1, const Data& d2 )
                 : kind( d1.kind ), isComplete( d1.isComplete || d2.isComplete ) {}
 
@@ -158 +158 @@
         };
 
-        TypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage, Type* b, 
+        TypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage, Type* b,
                 Kind k, bool s, Type* i = nullptr )
         : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == Ttype || s ), init( i ) {}
@@ -174 +174 @@
 class TypedefDecl final : public NamedTypeDecl {
 public:
-        TypedefDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage, 
+        TypedefDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage,
                 Type* b, Linkage::Spec spec = Linkage::Cforall )
         : NamedTypeDecl( loc, name, storage, b, spec ) {}
@@ -275 +275 @@
 };
 
+
+//=================================================================================================
+/// This disgusting and giant piece of boiler-plate is here to solve a cyclic dependency
+/// remove only if there is a better solution
+/// The problem is that ast::ptr< ... > uses increment/decrement which won't work well with
+/// forward declarations
+inline void increment( const class Decl * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class Decl * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class DeclWithType * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class DeclWithType * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class ObjectDecl * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class ObjectDecl * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class FunctionDecl * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class FunctionDecl * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class AggregateDecl * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class AggregateDecl * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class StructDecl * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class StructDecl * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class UnionDecl * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class UnionDecl * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class EnumDecl * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class EnumDecl * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class TraitDecl * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class TraitDecl * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class NamedTypeDecl * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class NamedTypeDecl * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class TypeDecl * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class TypeDecl * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class FtypeDecl * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class FtypeDecl * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class DtypeDecl * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class DtypeDecl * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class TypedefDecl * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class TypedefDecl * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class AsmDecl * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class AsmDecl * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class StaticAssertDecl * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class StaticAssertDecl * node, Node::ref_type ref ) { node->decrement(ref); }
+
 }