Changes in src/AST/Type.hpp [f3cc5b6:87701b6]

File:

• src/AST/Type.hpp (modified) (37 diffs)

src/AST/Type.hpp

@@ -29 +29 @@
 #include "Visitor.hpp"
 
-// Must be included in *all* AST classes; should be #undef'd at the end of the file
-#define MUTATE_FRIEND template<typename node_t> friend auto mutate(const node_t * node);
-
 namespace ast {
 
@@ -37 +34 @@
 public:
         CV::Qualifiers qualifiers;
-        
+
         Type( CV::Qualifiers q = {} ) : qualifiers(q) {}
 
@@ -73 +70 @@
 private:
         virtual Type * clone() const override = 0;
-        MUTATE_FRIEND
 };
 
@@ -80 +76 @@
 public:
         VoidType( CV::Qualifiers q = {} ) : Type( q ) {}
-        
+
         unsigned size() const override { return 0; }
         bool isVoid() const override { return true; }
@@ -88 +84 @@
 private:
         VoidType * clone() const override { return new VoidType{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -151 +146 @@
 private:
         BasicType * clone() const override { return new BasicType{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -171 +165 @@
 
         PointerType( const Type * b, CV::Qualifiers q = {} ) : Type(q), base(b), dimension() {}
-        PointerType( const Type * b, const Expr * d, LengthFlag vl, DimensionFlag s, 
+        PointerType( const Type * b, const Expr * d, LengthFlag vl, DimensionFlag s,
                 CV::Qualifiers q = {} ) : Type(q), base(b), dimension(d), isVarLen(vl), isStatic(s) {}
 
@@ -182 +176 @@
 private:
         PointerType * clone() const override { return new PointerType{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -193 +186 @@
         DimensionFlag isStatic;
 
-        ArrayType( const Type * b, const Expr * d, LengthFlag vl, DimensionFlag s, 
+        ArrayType( const Type * b, const Expr * d, LengthFlag vl, DimensionFlag s,
                 CV::Qualifiers q = {} ) : Type(q), base(b), dimension(d), isVarLen(vl), isStatic(s) {}
 
@@ -204 +197 @@
 private:
         ArrayType * clone() const override { return new ArrayType{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -224 +216 @@
 private:
         ReferenceType * clone() const override { return new ReferenceType{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -233 +224 @@
         ptr<Type> child;
 
-        QualifiedType( const Type * p, const Type * c, CV::Qualifiers q = {} ) 
+        QualifiedType( const Type * p, const Type * c, CV::Qualifiers q = {} )
         : Type(q), parent(p), child(c) {}
 
@@ -239 +230 @@
 private:
         QualifiedType * clone() const override { return new QualifiedType{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -249 +239 @@
         ForallList forall;
 
-        ParameterizedType( ForallList&& fs = {}, CV::Qualifiers q = {} ) 
+        ParameterizedType( ForallList&& fs = {}, CV::Qualifiers q = {} )
         : Type(q), forall(std::move(fs)) {}
         ParameterizedType( CV::Qualifiers q ) : Type(q), forall() {}
@@ -255 +245 @@
 private:
         virtual ParameterizedType * clone() const override = 0;
-        MUTATE_FRIEND
 };
 
@@ -267 +256 @@
         std::vector<ptr<DeclWithType>> params;
 
-        /// Does the function accept a variable number of arguments following the arguments specified 
+        /// Does the function accept a variable number of arguments following the arguments specified
         /// in the parameters list.
         /// This could be because of
@@ -285 +274 @@
 private:
         FunctionType * clone() const override { return new FunctionType{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -296 +284 @@
         bool hoistType = false;
 
-        ReferenceToType( const std::string& n, CV::Qualifiers q = {}, 
+        ReferenceToType( const std::string& n, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ParameterizedType(q), params(), attributes(std::move(as)), name(n) {}
@@ -307 +295 @@
 private:
         virtual ReferenceToType * clone() const override = 0;
-        MUTATE_FRIEND
 
 protected:
@@ -319 +306 @@
         readonly<StructDecl> base;
 
-        StructInstType( const std::string& n, CV::Qualifiers q = {}, 
+        StructInstType( const std::string& n, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base() {}
-        StructInstType( const StructDecl * b, CV::Qualifiers q = {}, 
+        StructInstType( const StructDecl * b, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} );
-        
+
         bool isComplete() const override;
 
@@ -332 +319 @@
 private:
         StructInstType * clone() const override { return new StructInstType{ *this }; }
-        MUTATE_FRIEND
 
         std::string typeString() const override { return "struct"; }
@@ -342 +328 @@
         readonly<UnionDecl> base;
 
-        UnionInstType( const std::string& n, CV::Qualifiers q = {}, 
+        UnionInstType( const std::string& n, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base() {}
-        UnionInstType( const UnionDecl * b, CV::Qualifiers q = {}, 
+        UnionInstType( const UnionDecl * b, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} );
-        
+
         bool isComplete() const override;
 
@@ -355 +341 @@
 private:
         UnionInstType * clone() const override { return new UnionInstType{ *this }; }
-        MUTATE_FRIEND
 
         std::string typeString() const override { return "union"; }
@@ -365 +350 @@
         readonly<EnumDecl> base;
 
-        EnumInstType( const std::string& n, CV::Qualifiers q = {}, 
+        EnumInstType( const std::string& n, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base() {}
-        EnumInstType( const EnumDecl * b, CV::Qualifiers q = {}, 
+        EnumInstType( const EnumDecl * b, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} );
-        
+
         bool isComplete() const override;
 
@@ -378 +363 @@
 private:
         EnumInstType * clone() const override { return new EnumInstType{ *this }; }
-        MUTATE_FRIEND
 
         std::string typeString() const override { return "enum"; }
@@ -388 +372 @@
         readonly<TraitDecl> base;
 
-        TraitInstType( const std::string& n, CV::Qualifiers q = {}, 
+        TraitInstType( const std::string& n, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base() {}
-        TraitInstType( const TraitDecl * b, CV::Qualifiers q = {}, 
+        TraitInstType( const TraitDecl * b, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} );
-        
+
         // not meaningful for TraitInstType
         bool isComplete() const override { assert(false); }
@@ -402 +386 @@
 private:
         TraitInstType * clone() const override { return new TraitInstType{ *this }; }
-        MUTATE_FRIEND
 
         std::string typeString() const override { return "trait"; }
@@ -413 +396 @@
         TypeVar::Kind kind;
 
-        TypeInstType( const std::string& n, const TypeDecl * b, CV::Qualifiers q = {}, 
+        TypeInstType( const std::string& n, const TypeDecl * b, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base( b ), kind( b->kind ) {}
-        TypeInstType( const std::string& n, TypeVar::Kind k, CV::Qualifiers q = {}, 
+        TypeInstType( const std::string& n, TypeVar::Kind k, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base(), kind( k ) {}
@@ -431 +414 @@
 private:
         TypeInstType * clone() const override { return new TypeInstType{ *this }; }
-        MUTATE_FRIEND
 
         std::string typeString() const override { return "type"; }
@@ -448 +430 @@
         iterator begin() const { return types.begin(); }
         iterator end() const { return types.end(); }
-        
+
         unsigned size() const override { return types.size(); }
 
         const Type * getComponent( unsigned i ) override {
-                assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", 
+                assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d",
                         i, size() );
                 return *(begin()+i);
@@ -460 +442 @@
 private:
         TupleType * clone() const override { return new TupleType{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -469 +450 @@
         enum Kind { Typeof, Basetypeof } kind;
 
-        TypeofType( const Expr * e, Kind k = Typeof, CV::Qualifiers q = {} ) 
+        TypeofType( const Expr * e, Kind k = Typeof, CV::Qualifiers q = {} )
         : Type(q), expr(e), kind(k) {}
 
@@ -475 +456 @@
 private:
         TypeofType * clone() const override { return new TypeofType{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -482 +462 @@
 public:
         VarArgsType( CV::Qualifiers q = {} ) : Type( q ) {}
-        
+
         const Type * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
         VarArgsType * clone() const override { return new VarArgsType{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -493 +472 @@
 public:
         ZeroType( CV::Qualifiers q = {} ) : Type( q ) {}
-        
+
         const Type * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
         ZeroType * clone() const override { return new ZeroType{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -508 +486 @@
 private:
         OneType * clone() const override { return new OneType{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -519 +496 @@
 private:
         GlobalScopeType * clone() const override { return new GlobalScopeType{ *this }; }
-        MUTATE_FRIEND
-};
-
-//=================================================================================================
-/// 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 Type * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class Type * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class VoidType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class VoidType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class BasicType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class BasicType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class PointerType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class PointerType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ArrayType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ArrayType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ReferenceType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ReferenceType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class QualifiedType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class QualifiedType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class FunctionType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class FunctionType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ReferenceToType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ReferenceToType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class StructInstType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class StructInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class UnionInstType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class UnionInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class EnumInstType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class EnumInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class TraitInstType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class TraitInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class TypeInstType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class TypeInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class TupleType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class TupleType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class TypeofType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class TypeofType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class VarArgsType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class VarArgsType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ZeroType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ZeroType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class OneType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class OneType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class GlobalScopeType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class GlobalScopeType * node, Node::ref_type ref ) { node->decrement( ref ); }
+};
 
 }
-
-#undef MUTATE_FRIEND
 
 // Local Variables: //