Changes in / [41b24c8:e61207e7]

Files:

• libcfa/src/concurrency/coroutine.hfa (modified) (1 diff)
• src/AST/Convert.cpp (modified) (2 diffs)
• src/AST/Decl.hpp (modified) (15 diffs)
• src/AST/Expr.hpp (modified) (24 diffs)
• src/AST/Init.hpp (modified) (6 diffs)
• src/AST/Pass.impl.hpp (modified) (1 diff)
• src/AST/Stmt.hpp (modified) (24 diffs)
• src/AST/Type.hpp (modified) (22 diffs)
• src/AST/TypeSubstitution.cpp (deleted)
• src/AST/TypeSubstitution.hpp (deleted)

libcfa/src/concurrency/coroutine.hfa

@@ -49 +49 @@
 
 forall(dtype T | is_coroutine(T))
-static inline T & resume(T & cor);
+static inline void resume(T & cor);
 
 forall(dtype T | is_coroutine(T))

src/AST/Convert.cpp

@@ -135 +135 @@
                 decl->parent = parent;
                 decl->body   = old->body;
-                decl->params = params;
+                decl->parameters = params;
                 decl->members    = members;
                 decl->extension  = old->extension;
@@ -592 +592 @@
 
         }
-
-        virtual void visit( AttrExpr * ) override final {
-
-                assert( 0 );
-        }
 };
 

src/AST/Decl.hpp

@@ -30 +30 @@
 #include "Parser/ParseNode.h"  // for DeclarationNode::Aggregate
 
-// 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 node_t * mutate(const node_t * node);
-
 namespace ast {
 
@@ -58 +55 @@
 private:
         Decl * clone() const override = 0;
-        MUTATE_FRIEND
 };
 
@@ -91 +87 @@
 private:
         DeclWithType * clone() const override = 0;
-        MUTATE_FRIEND
 };
 
@@ -113 +108 @@
 private:
         ObjectDecl * clone() const override { return new ObjectDecl{ *this }; }
-        MUTATE_FRIEND
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -137 +135 @@
 private:
         FunctionDecl * clone() const override { return new FunctionDecl( *this ); }
-        MUTATE_FRIEND
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -156 +157 @@
 private:
         NamedTypeDecl* clone() const override = 0;
-        MUTATE_FRIEND
 };
 
@@ -198 +198 @@
 private:
         TypeDecl * clone() const override { return new TypeDecl{ *this }; }
-        MUTATE_FRIEND
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -213 +216 @@
 private:
         TypedefDecl * clone() const override { return new TypedefDecl{ *this }; }
-        MUTATE_FRIEND
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -232 +238 @@
         AggregateDecl* set_body( bool b ) { body = b; return this; }
 
-private:
-        AggregateDecl * clone() const override = 0;
-        MUTATE_FRIEND
-
 protected:
         /// Produces a name for the kind of aggregate
@@ -258 +260 @@
 private:
         StructDecl * clone() const override { return new StructDecl{ *this }; }
-        MUTATE_FRIEND
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 
         std::string typeString() const override { return "struct"; }
@@ -273 +278 @@
 private:
         UnionDecl * clone() const override { return new UnionDecl{ *this }; }
-        MUTATE_FRIEND
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 
         std::string typeString() const override { return "union"; }
@@ -291 +299 @@
 private:
         EnumDecl * clone() const override { return new EnumDecl{ *this }; }
-        MUTATE_FRIEND
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 
         std::string typeString() const override { return "enum"; }
@@ -309 +320 @@
 private:
         TraitDecl * clone() const override { return new TraitDecl{ *this }; }
-        MUTATE_FRIEND
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 
         std::string typeString() const override { return "trait"; }
@@ -324 +338 @@
 private:
         AsmDecl *clone() const override { return new AsmDecl( *this ); }
-        MUTATE_FRIEND
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -338 +355 @@
 private:
         StaticAssertDecl * clone() const override { return new StaticAssertDecl( *this ); }
-        MUTATE_FRIEND
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
 }
-
-#undef MUTATE_FRIEND
 
 // Local Variables: //

src/AST/Expr.hpp

@@ -27 +27 @@
 #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 {
 
@@ -130 +127 @@
 private:
         Expr * clone() const override = 0;
-        MUTATE_FRIEND
 };
 
@@ -145 +141 @@
 private:
         ApplicationExpr * clone() const override { return new ApplicationExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -165 +160 @@
 private:
         UntypedExpr * clone() const override { return new UntypedExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -179 +173 @@
 private:
         NameExpr * clone() const override { return new NameExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -192 +185 @@
 private:
         AddressExpr * clone() const override { return new AddressExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -206 +198 @@
 private:
         LabelAddressExpr * clone() const override { return new LabelAddressExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -226 +217 @@
 private:
         CastExpr * clone() const override { return new CastExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -244 +234 @@
 private:
         KeywordCastExpr * clone() const override { return new KeywordCastExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -258 +247 @@
 private:
         VirtualCastExpr * clone() const override { return new VirtualCastExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -273 +261 @@
 private:
         UntypedMemberExpr * clone() const override { return new UntypedMemberExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -287 +274 @@
 private:
         MemberExpr * clone() const override { return new MemberExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -303 +289 @@
 private:
         VariableExpr * clone() const override { return new VariableExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -347 +332 @@
 private:
         ConstantExpr * clone() const override { return new ConstantExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -363 +347 @@
 private:
         SizeofExpr * clone() const override { return new SizeofExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -379 +362 @@
 private:
         AlignofExpr * clone() const override { return new AlignofExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -394 +376 @@
 private:
         UntypedOffsetofExpr * clone() const override { return new UntypedOffsetofExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -408 +389 @@
 private:
         OffsetofExpr * clone() const override { return new OffsetofExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -421 +401 @@
 private:
         OffsetPackExpr * clone() const override { return new OffsetPackExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -439 +418 @@
 private:
         LogicalExpr * clone() const override { return new LogicalExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -455 +433 @@
 private:
         ConditionalExpr * clone() const override { return new ConditionalExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -470 +447 @@
 private:
         CommaExpr * clone() const override { return new CommaExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -483 +459 @@
 private:
         TypeExpr * clone() const override { return new TypeExpr{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -495 +470 @@
 
 }
-
-#undef MUTATE_FRIEND
 
 // Local Variables: //

src/AST/Init.hpp

@@ -23 +23 @@
 #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 node_t * mutate(const node_t * node);
-
 namespace ast {
 
@@ -43 +40 @@
 private:
         Designation* clone() const override { return new Designation{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -59 +55 @@
 private:
         Init * clone() const override = 0;
-        MUTATE_FRIEND
 };
 
@@ -74 +69 @@
 private:
         SingleInit * clone() const override { return new SingleInit{ *this }; }
-        MUTATE_FRIEND
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -99 +97 @@
 private:
         ListInit * clone() const override { return new ListInit{ *this }; }
-        MUTATE_FRIEND
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
@@ -119 +120 @@
 private:
         ConstructorInit * clone() const override { return new ConstructorInit{ *this }; }
-        MUTATE_FRIEND
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
 }
-
-#undef MUTATE_FRIEND
 
 // Local Variables: //

src/AST/Pass.impl.hpp

@@ -19 +19 @@
 #include <type_traits>
 #include <unordered_map>
-
-#include "AST/TypeSubstitution.hpp"
 
 #define VISIT_START( node ) \

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
+        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: //

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 {
 
@@ -73 +70 @@
 private:
         virtual Type * clone() const override = 0;
-        MUTATE_FRIEND
 };
 
@@ -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
 };
 
@@ -182 +176 @@
 private:
         PointerType * clone() const override { return new PointerType{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -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
 };
 
@@ -239 +230 @@
 private:
         QualifiedType * clone() const override { return new QualifiedType{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -255 +245 @@
 private:
         virtual ParameterizedType * clone() const override = 0;
-        MUTATE_FRIEND
 };
 
@@ -285 +274 @@
 private:
         FunctionType * clone() const override { return new FunctionType{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -307 +295 @@
 private:
         virtual ReferenceToType * clone() const override = 0;
-        MUTATE_FRIEND
 
 protected:
@@ -332 +319 @@
 private:
         StructInstType * clone() const override { return new StructInstType{ *this }; }
-        MUTATE_FRIEND
 
         std::string typeString() const override { return "struct"; }
@@ -355 +341 @@
 private:
         UnionInstType * clone() const override { return new UnionInstType{ *this }; }
-        MUTATE_FRIEND
 
         std::string typeString() const override { return "union"; }
@@ -378 +363 @@
 private:
         EnumInstType * clone() const override { return new EnumInstType{ *this }; }
-        MUTATE_FRIEND
 
         std::string typeString() const override { return "enum"; }
@@ -402 +386 @@
 private:
         TraitInstType * clone() const override { return new TraitInstType{ *this }; }
-        MUTATE_FRIEND
 
         std::string typeString() const override { return "trait"; }
@@ -431 +414 @@
 private:
         TypeInstType * clone() const override { return new TypeInstType{ *this }; }
-        MUTATE_FRIEND
 
         std::string typeString() const override { return "type"; }
@@ -460 +442 @@
 private:
         TupleType * clone() const override { return new TupleType{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -475 +456 @@
 private:
         TypeofType * clone() const override { return new TypeofType{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -486 +466 @@
 private:
         VarArgsType * clone() const override { return new VarArgsType{ *this }; }
-        MUTATE_FRIEND
 };
 
@@ -497 +476 @@
 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
 };
 
 }
-
-#undef MUTATE_FRIEND
 
 // Local Variables: //