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

File:

• src/AST/Stmt.hpp (modified) (24 diffs)

src/AST/Stmt.hpp

@@ -26 +26 @@
 #include "Common/CodeLocation.h"
 
-// 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 {
 
@@ -38 +35 @@
         std::vector<Label> labels;
 
-        Stmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
+        Stmt( const CodeLocation& loc, std::vector<Label>&& labels = {} )
         : ParseNode(loc), labels(std::move(labels)) {}
 
         Stmt(const Stmt& o) : ParseNode(o), labels(o.labels) {}
 
-        const Stmt * accept( Visitor & v ) const override = 0;
-private:
-        Stmt * clone() const override = 0;
-        MUTATE_FRIEND
+        const Stmt* accept( Visitor& v ) const override = 0;
+private:
+        Stmt* clone() const override = 0;
 };
 
@@ -54 +50 @@
         std::list<ptr<Stmt>> kids;
 
-        CompoundStmt(const CodeLocation & loc, std::list<ptr<Stmt>> && ks = {} )
+        CompoundStmt(const CodeLocation& loc, std::list<ptr<Stmt>>&& ks = {} )
         : Stmt(loc), kids(std::move(ks)) {}
 
@@ -60 +56 @@
         CompoundStmt( CompoundStmt&& o ) = default;
 
-        void push_back( Stmt * s ) { kids.emplace_back( s ); }
-        void push_front( Stmt * s ) { kids.emplace_front( s ); }
-
-        const CompoundStmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        CompoundStmt * clone() const override { return new CompoundStmt{ *this }; }
-        MUTATE_FRIEND
+        void push_back( Stmt* s ) { kids.emplace_back( s ); }
+        void push_front( Stmt* s ) { kids.emplace_front( s ); }
+
+        const CompoundStmt* accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        CompoundStmt* clone() const override { return new CompoundStmt{ *this }; }
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -72 +71 @@
 class NullStmt final : public Stmt {
 public:
-        NullStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
+        NullStmt( const CodeLocation& loc, std::vector<Label>&& labels = {} )
         : Stmt(loc, std::move(labels)) {}
 
-        const NullStmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        NullStmt * clone() const override { return new NullStmt{ *this }; }
-        MUTATE_FRIEND
+        const NullStmt* accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        NullStmt* clone() const override { return new NullStmt{ *this }; }
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -88 +90 @@
         ExprStmt( const CodeLocation & loc, const Expr * e ) : Stmt(loc), expr(e) {}
 
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+        const Stmt * accept( Visitor& v ) const override { return v.visit( this ); }
 private:
         ExprStmt * clone() const override { return new ExprStmt{ *this }; }
-        MUTATE_FRIEND
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -102 +107 @@
         std::vector<Label> gotoLabels;
 
-        AsmStmt( const CodeLocation & loc, bool isVolatile, const Expr * instruction,
-                std::vector<ptr<Expr>> && output, std::vector<ptr<Expr>> && input,
-                std::vector<ptr<ConstantExpr>> && clobber, std::vector<Label> && gotoLabels,
-                std::vector<Label> && labels = {})
+        AsmStmt( const CodeLocation& loc, bool isVolatile, const Expr * instruction,
+                std::vector<ptr<Expr>>&& output, std::vector<ptr<Expr>>&& input,
+                std::vector<ptr<ConstantExpr>>&& clobber, std::vector<Label>&& gotoLabels,
+                std::vector<Label>&& labels = {})
         : Stmt(loc, std::move(labels)), isVolatile(isVolatile), instruction(instruction),
           output(std::move(output)), input(std::move(input)), clobber(std::move(clobber)),
           gotoLabels(std::move(gotoLabels)) {}
 
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        AsmStmt * clone() const override { return new AsmStmt{ *this }; }
-        MUTATE_FRIEND
+        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        AsmStmt* clone() const override { return new AsmStmt{ *this }; }
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -120 +128 @@
         std::string directive;
 
-        DirectiveStmt( const CodeLocation & loc, const std::string & directive,
-                std::vector<Label> && labels = {} )
+        DirectiveStmt( const CodeLocation& loc, const std::string & directive,
+                std::vector<Label>&& labels = {} )
         : Stmt(loc, std::move(labels)), directive(directive) {}
 
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        DirectiveStmt * clone() const override { return new DirectiveStmt{ *this }; }
-        MUTATE_FRIEND
+        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        DirectiveStmt* clone() const override { return new DirectiveStmt{ *this }; }
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -137 +148 @@
         std::vector<ptr<Stmt>> inits;
 
-        IfStmt( const CodeLocation & loc, const Expr * cond, const Stmt * thenPart,
-                Stmt * const elsePart, std::vector<ptr<Stmt>> && inits,
-                std::vector<Label> && labels = {} )
+        IfStmt( const CodeLocation& loc, const Expr* cond, const Stmt* thenPart,
+                Stmt * const elsePart, std::vector<ptr<Stmt>>&& inits,
+                std::vector<Label>&& labels = {} )
         : Stmt(loc, std::move(labels)), cond(cond), thenPart(thenPart), elsePart(elsePart),
           inits(std::move(inits)) {}
 
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        IfStmt * clone() const override { return new IfStmt{ *this }; }
-        MUTATE_FRIEND
+        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        IfStmt* clone() const override { return new IfStmt{ *this }; }
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -154 +168 @@
         std::vector<ptr<Stmt>> stmts;
 
-        SwitchStmt( const CodeLocation & loc, const Expr * cond, std::vector<ptr<Stmt>> && stmts,
-                std::vector<Label> && labels = {} )
+        SwitchStmt( const CodeLocation& loc, const Expr* cond, std::vector<ptr<Stmt>>&& stmts,
+                std::vector<Label>&& labels = {} )
         : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
 
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        SwitchStmt * clone() const override { return new SwitchStmt{ *this }; }
-        MUTATE_FRIEND
+        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        SwitchStmt* clone() const override { return new SwitchStmt{ *this }; }
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -169 +186 @@
         std::vector<ptr<Stmt>> stmts;
 
-        CaseStmt( const CodeLocation & loc, const Expr * cond, std::vector<ptr<Stmt>> && stmts,
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
+    CaseStmt( const CodeLocation& loc, const Expr* cond, std::vector<ptr<Stmt>>&& stmts,
+        std::vector<Label>&& labels = {} )
+    : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
 
         bool isDefault() { return !cond; }
 
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        CaseStmt * clone() const override { return new CaseStmt{ *this }; }
-        MUTATE_FRIEND
+        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        CaseStmt* clone() const override { return new CaseStmt{ *this }; }
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -188 +208 @@
         bool isDoWhile;
 
-        WhileStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
-                std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, std::vector<Label> && labels = {} )
+        WhileStmt( const CodeLocation& loc, const Expr* cond, const Stmt* body,
+                std::vector<ptr<Stmt>>&& inits, bool isDoWhile = false, std::vector<Label>&& labels = {} )
         : Stmt(loc, std::move(labels)), cond(cond), body(body), inits(std::move(inits)),
           isDoWhile(isDoWhile) {}
 
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        WhileStmt * clone() const override { return new WhileStmt{ *this }; }
-        MUTATE_FRIEND
+        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        WhileStmt* clone() const override { return new WhileStmt{ *this }; }
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -206 +229 @@
         ptr<Stmt> body;
 
-        ForStmt( const CodeLocation & loc, std::vector<ptr<Stmt>> && inits, const Expr * cond,
-                const Expr * inc, const Stmt * body, std::vector<Label> && labels = {} )
+        ForStmt( const CodeLocation& loc, std::vector<ptr<Stmt>>&& inits, const Expr* cond,
+                const Expr* inc, const Stmt* body, std::vector<Label>&& labels = {} )
         : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc),
           body(body) {}
 
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        ForStmt * clone() const override { return new ForStmt{ *this }; }
-        MUTATE_FRIEND
+        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        ForStmt* clone() const override { return new ForStmt{ *this }; }
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -227 +253 @@
         Kind kind;
 
-        BranchStmt( const CodeLocation & loc, Kind kind, Label target,
-                std::vector<Label> && labels = {} );
-        BranchStmt( const CodeLocation & loc, const Expr * computedTarget,
-                std::vector<Label> && labels = {} )
+        BranchStmt( const CodeLocation& loc, Kind kind, Label target,
+                std::vector<Label>&& labels = {} );
+        BranchStmt( const CodeLocation& loc, const Expr* computedTarget,
+                std::vector<Label>&& labels = {} )
         : Stmt(loc, std::move(labels)), originalTarget(loc), target(loc),
           computedTarget(computedTarget), kind(Goto) {}
@@ -236 +262 @@
         const char * kindName() { return kindNames[kind]; }
 
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        BranchStmt * clone() const override { return new BranchStmt{ *this }; }
-        MUTATE_FRIEND
+        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        BranchStmt* clone() const override { return new BranchStmt{ *this }; }
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 
         static const char * kindNames[kindEnd];
@@ -248 +277 @@
         ptr<Expr> expr;
 
-        ReturnStmt( const CodeLocation & loc, const Expr * expr, std::vector<Label> && labels = {} )
+        ReturnStmt( const CodeLocation& loc, const Expr* expr, std::vector<Label>&& labels = {} )
         : Stmt(loc, std::move(labels)), expr(expr) {}
 
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        ReturnStmt * clone() const override { return new ReturnStmt{ *this }; }
-        MUTATE_FRIEND
+        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        ReturnStmt* clone() const override { return new ReturnStmt{ *this }; }
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -265 +297 @@
         Kind kind;
 
-        ThrowStmt( const CodeLocation & loc, Kind kind, const Expr * expr, const Expr * target,
-                std::vector<Label> && labels = {} )
+        ThrowStmt( const CodeLocation& loc, Kind kind, const Expr* expr, const Expr* target,
+                std::vector<Label>&& labels = {} )
         : Stmt(loc, std::move(labels)), expr(expr), target(target), kind(kind) {}
 
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        ThrowStmt * clone() const override { return new ThrowStmt{ *this }; }
-        MUTATE_FRIEND
+        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        ThrowStmt* clone() const override { return new ThrowStmt{ *this }; }
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -281 +316 @@
         ptr<FinallyStmt> finally;
 
-        TryStmt( const CodeLocation & loc, const CompoundStmt * body,
-                std::vector<ptr<CatchStmt>> && handlers, const FinallyStmt * finally,
-                std::vector<Label> && labels = {} )
+        TryStmt( const CodeLocation& loc, const CompoundStmt* body,
+                std::vector<ptr<CatchStmt>>&& handlers, const FinallyStmt* finally,
+                std::vector<Label>&& labels = {} )
         : Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}
 
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        TryStmt * clone() const override { return new TryStmt{ *this }; }
-        MUTATE_FRIEND
+        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        TryStmt* clone() const override { return new TryStmt{ *this }; }
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -301 +339 @@
         Kind kind;
 
-        CatchStmt( const CodeLocation & loc, Kind kind, const Decl * decl, const Expr * cond,
-                const Stmt * body, std::vector<Label> && labels = {} )
+        CatchStmt( const CodeLocation& loc, Kind kind, const Decl* decl, const Expr* cond,
+                const Stmt* body, std::vector<Label>&& labels = {} )
         : Stmt(loc, std::move(labels)), decl(decl), cond(cond), body(body), kind(kind) {}
 
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        CatchStmt * clone() const override { return new CatchStmt{ *this }; }
-        MUTATE_FRIEND
+        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        CatchStmt* clone() const override { return new CatchStmt{ *this }; }
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -315 +356 @@
         ptr<CompoundStmt> body;
 
-        FinallyStmt( const CodeLocation & loc, const CompoundStmt * body,
-                std::vector<Label> && labels = {} )
+        FinallyStmt( const CodeLocation& loc, const CompoundStmt* body,
+                std::vector<Label>&& labels = {} )
         : Stmt(loc, std::move(labels)), body(body) {}
 
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        FinallyStmt * clone() const override { return new FinallyStmt{ *this }; }
-        MUTATE_FRIEND
+        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        FinallyStmt* clone() const override { return new FinallyStmt{ *this }; }
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -353 +397 @@
         OrElse orElse;
 
-        WaitForStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
+        WaitForStmt( const CodeLocation& loc, std::vector<Label>&& labels = {} )
         : Stmt(loc, std::move(labels)) {}
 
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        WaitForStmt * clone() const override { return new WaitForStmt{ *this }; }
-        MUTATE_FRIEND
+        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        WaitForStmt* clone() const override { return new WaitForStmt{ *this }; }
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -367 +414 @@
         ptr<Stmt> stmt;
 
-        WithStmt( const CodeLocation & loc, std::vector<ptr<Expr>> && exprs, const Stmt * stmt,
-                std::vector<Label> && labels = {} )
+        WithStmt( const CodeLocation& loc, std::vector<ptr<Expr>>&& exprs, const Stmt* stmt,
+                std::vector<Label>&& labels = {} )
         : Stmt(loc, std::move(labels)), exprs(std::move(exprs)), stmt(stmt) {}
 
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        WithStmt * clone() const override { return new WithStmt{ *this }; }
-        MUTATE_FRIEND
+        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        WithStmt* clone() const override { return new WithStmt{ *this }; }
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -381 +431 @@
         ptr<Decl> decl;
 
-        DeclStmt( const CodeLocation & loc, const Decl * decl, std::vector<Label> && labels = {} )
+        DeclStmt( const CodeLocation& loc, const Decl* decl, std::vector<Label>&& labels = {} )
         : Stmt(loc, std::move(labels)), decl(decl) {}
 
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        DeclStmt * clone() const override { return new DeclStmt{ *this }; }
-        MUTATE_FRIEND
+        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        DeclStmt* clone() const override { return new DeclStmt{ *this }; }
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -394 +447 @@
         readonly<Stmt> callStmt;
 
-        ImplicitCtorDtorStmt( const CodeLocation & loc, const Stmt * callStmt,
-                std::vector<Label> && labels = {} )
+        ImplicitCtorDtorStmt( const CodeLocation& loc, const Stmt* callStmt,
+                std::vector<Label>&& labels = {} )
         : Stmt(loc, std::move(labels)), callStmt(callStmt) {}
 
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        ImplicitCtorDtorStmt * clone() const override { return new ImplicitCtorDtorStmt{ *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 Stmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class Stmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class CompoundStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class CompoundStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ExprStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ExprStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class AsmStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class AsmStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class DirectiveStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class DirectiveStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class IfStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class IfStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class WhileStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class WhileStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ForStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ForStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class SwitchStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class SwitchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class CaseStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class CaseStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class BranchStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class BranchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ReturnStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ReturnStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ThrowStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ThrowStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class TryStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class TryStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class CatchStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class CatchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class FinallyStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class FinallyStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class WaitForStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class WaitForStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class WithStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class WithStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class DeclStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class DeclStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class NullStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class NullStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ImplicitCtorDtorStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ImplicitCtorDtorStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
+        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        ImplicitCtorDtorStmt* clone() const override { return new ImplicitCtorDtorStmt{ *this }; }
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
+};
 
 }
-
-#undef MUTATE_FRIEND
 
 // Local Variables: //