Changeset 41b24c8 for src

Timestamp:

May 16, 2019, 4:23:47 PM (6 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:

acd80b4

Parents:

e61207e7 (diff), c671112 (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:

• Convert.cpp (modified) (2 diffs)
• Decl.hpp (modified) (15 diffs)
• Expr.hpp (modified) (24 diffs)
• Init.hpp (modified) (6 diffs)
• Pass.impl.hpp (modified) (1 diff)
• Stmt.hpp (modified) (24 diffs)
• Type.hpp (modified) (22 diffs)
• TypeSubstitution.cpp (added)
• TypeSubstitution.hpp (added)

src/AST/Convert.cpp

@@ -135 +135 @@
                 decl->parent = parent;
                 decl->body   = old->body;
-                decl->parameters = params;
+                decl->params = 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 {
 
@@ -55 +58 @@
 private:
         Decl * clone() const override = 0;
+        MUTATE_FRIEND
 };
 
@@ -87 +91 @@
 private:
         DeclWithType * clone() const override = 0;
+        MUTATE_FRIEND
 };
 
@@ -108 +113 @@
 private:
         ObjectDecl * clone() const override { return new ObjectDecl{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
@@ -135 +137 @@
 private:
         FunctionDecl * clone() const override { return new FunctionDecl( *this ); }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
@@ -157 +156 @@
 private:
         NamedTypeDecl* clone() const override = 0;
+        MUTATE_FRIEND
 };
 
@@ -198 +198 @@
 private:
         TypeDecl * clone() const override { return new TypeDecl{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
@@ -216 +213 @@
 private:
         TypedefDecl * clone() const override { return new TypedefDecl{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
@@ -238 +232 @@
         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
@@ -260 +258 @@
 private:
         StructDecl * clone() const override { return new StructDecl{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        MUTATE_FRIEND
 
         std::string typeString() const override { return "struct"; }
@@ -278 +273 @@
 private:
         UnionDecl * clone() const override { return new UnionDecl{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        MUTATE_FRIEND
 
         std::string typeString() const override { return "union"; }
@@ -299 +291 @@
 private:
         EnumDecl * clone() const override { return new EnumDecl{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        MUTATE_FRIEND
 
         std::string typeString() const override { return "enum"; }
@@ -320 +309 @@
 private:
         TraitDecl * clone() const override { return new TraitDecl{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        MUTATE_FRIEND
 
         std::string typeString() const override { return "trait"; }
@@ -338 +324 @@
 private:
         AsmDecl *clone() const override { return new AsmDecl( *this ); }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
@@ -355 +338 @@
 private:
         StaticAssertDecl * clone() const override { return new StaticAssertDecl( *this ); }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
 }
+
+#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 {
 
@@ -127 +130 @@
 private:
         Expr * clone() const override = 0;
+        MUTATE_FRIEND
 };
 
@@ -141 +145 @@
 private:
         ApplicationExpr * clone() const override { return new ApplicationExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -160 +165 @@
 private:
         UntypedExpr * clone() const override { return new UntypedExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -173 +179 @@
 private:
         NameExpr * clone() const override { return new NameExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -185 +192 @@
 private:
         AddressExpr * clone() const override { return new AddressExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -198 +206 @@
 private:
         LabelAddressExpr * clone() const override { return new LabelAddressExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -217 +226 @@
 private:
         CastExpr * clone() const override { return new CastExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -234 +244 @@
 private:
         KeywordCastExpr * clone() const override { return new KeywordCastExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -247 +258 @@
 private:
         VirtualCastExpr * clone() const override { return new VirtualCastExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -261 +273 @@
 private:
         UntypedMemberExpr * clone() const override { return new UntypedMemberExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -274 +287 @@
 private:
         MemberExpr * clone() const override { return new MemberExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -289 +303 @@
 private:
         VariableExpr * clone() const override { return new VariableExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -332 +347 @@
 private:
         ConstantExpr * clone() const override { return new ConstantExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -347 +363 @@
 private:
         SizeofExpr * clone() const override { return new SizeofExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -362 +379 @@
 private:
         AlignofExpr * clone() const override { return new AlignofExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -376 +394 @@
 private:
         UntypedOffsetofExpr * clone() const override { return new UntypedOffsetofExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -389 +408 @@
 private:
         OffsetofExpr * clone() const override { return new OffsetofExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -401 +421 @@
 private:
         OffsetPackExpr * clone() const override { return new OffsetPackExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -418 +439 @@
 private:
         LogicalExpr * clone() const override { return new LogicalExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -433 +455 @@
 private:
         ConditionalExpr * clone() const override { return new ConditionalExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -447 +470 @@
 private:
         CommaExpr * clone() const override { return new CommaExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -459 +483 @@
 private:
         TypeExpr * clone() const override { return new TypeExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -470 +495 @@
 
 }
+
+#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 {
 
@@ -40 +43 @@
 private:
         Designation* clone() const override { return new Designation{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -55 +59 @@
 private:
         Init * clone() const override = 0;
+        MUTATE_FRIEND
 };
 
@@ -69 +74 @@
 private:
         SingleInit * clone() const override { return new SingleInit{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
@@ -97 +99 @@
 private:
         ListInit * clone() const override { return new ListInit{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
@@ -120 +119 @@
 private:
         ConstructorInit * clone() const override { return new ConstructorInit{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
 }
+
+#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 {
 
@@ -35 +38 @@
         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;
+        const Stmt * accept( Visitor & v ) const override = 0;
+private:
+        Stmt * clone() const override = 0;
+        MUTATE_FRIEND
 };
 
@@ -50 +54 @@
         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)) {}
 
@@ -56 +60 @@
         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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        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
 };
 
@@ -71 +72 @@
 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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        const NullStmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        NullStmt * clone() const override { return new NullStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -90 +88 @@
         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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
@@ -107 +102 @@
         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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        AsmStmt * clone() const override { return new AsmStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -128 +120 @@
         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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        DirectiveStmt * clone() const override { return new DirectiveStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -148 +137 @@
         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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        IfStmt * clone() const override { return new IfStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -168 +154 @@
         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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        SwitchStmt * clone() const override { return new SwitchStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -186 +169 @@
         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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        CaseStmt * clone() const override { return new CaseStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -208 +188 @@
         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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        WhileStmt * clone() const override { return new WhileStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -229 +206 @@
         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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        ForStmt * clone() const override { return new ForStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -253 +227 @@
         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) {}
@@ -262 +236 @@
         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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        BranchStmt * clone() const override { return new BranchStmt{ *this }; }
+        MUTATE_FRIEND
 
         static const char * kindNames[kindEnd];
@@ -277 +248 @@
         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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        ReturnStmt * clone() const override { return new ReturnStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -297 +265 @@
         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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        ThrowStmt * clone() const override { return new ThrowStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -316 +281 @@
         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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        TryStmt * clone() const override { return new TryStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -339 +301 @@
         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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        CatchStmt * clone() const override { return new CatchStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -356 +315 @@
         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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        FinallyStmt * clone() const override { return new FinallyStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -397 +353 @@
         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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        WaitForStmt * clone() const override { return new WaitForStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -414 +367 @@
         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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        WithStmt * clone() const override { return new WithStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -431 +381 @@
         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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        DeclStmt * clone() const override { return new DeclStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -447 +394 @@
         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 }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend node_t * mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        ImplicitCtorDtorStmt * clone() const override { return new ImplicitCtorDtorStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
 }
+
+#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 {
 
@@ -70 +73 @@
 private:
         virtual Type * clone() const override = 0;
+        MUTATE_FRIEND
 };
 
@@ -84 +88 @@
 private:
         VoidType * clone() const override { return new VoidType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -146 +151 @@
 private:
         BasicType * clone() const override { return new BasicType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -176 +182 @@
 private:
         PointerType * clone() const override { return new PointerType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -197 +204 @@
 private:
         ArrayType * clone() const override { return new ArrayType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -216 +224 @@
 private:
         ReferenceType * clone() const override { return new ReferenceType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -230 +239 @@
 private:
         QualifiedType * clone() const override { return new QualifiedType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -245 +255 @@
 private:
         virtual ParameterizedType * clone() const override = 0;
+        MUTATE_FRIEND
 };
 
@@ -274 +285 @@
 private:
         FunctionType * clone() const override { return new FunctionType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -295 +307 @@
 private:
         virtual ReferenceToType * clone() const override = 0;
+        MUTATE_FRIEND
 
 protected:
@@ -319 +332 @@
 private:
         StructInstType * clone() const override { return new StructInstType{ *this }; }
+        MUTATE_FRIEND
 
         std::string typeString() const override { return "struct"; }
@@ -341 +355 @@
 private:
         UnionInstType * clone() const override { return new UnionInstType{ *this }; }
+        MUTATE_FRIEND
 
         std::string typeString() const override { return "union"; }
@@ -363 +378 @@
 private:
         EnumInstType * clone() const override { return new EnumInstType{ *this }; }
+        MUTATE_FRIEND
 
         std::string typeString() const override { return "enum"; }
@@ -386 +402 @@
 private:
         TraitInstType * clone() const override { return new TraitInstType{ *this }; }
+        MUTATE_FRIEND
 
         std::string typeString() const override { return "trait"; }
@@ -414 +431 @@
 private:
         TypeInstType * clone() const override { return new TypeInstType{ *this }; }
+        MUTATE_FRIEND
 
         std::string typeString() const override { return "type"; }
@@ -442 +460 @@
 private:
         TupleType * clone() const override { return new TupleType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -456 +475 @@
 private:
         TypeofType * clone() const override { return new TypeofType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -466 +486 @@
 private:
         VarArgsType * clone() const override { return new VarArgsType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -476 +497 @@
 private:
         ZeroType * clone() const override { return new ZeroType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -486 +508 @@
 private:
         OneType * clone() const override { return new OneType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -496 +519 @@
 private:
         GlobalScopeType * clone() const override { return new GlobalScopeType{ *this }; }
+        MUTATE_FRIEND
 };
 
 }
+
+#undef MUTATE_FRIEND
 
 // Local Variables: //