Changeset 204358b for src/AST/Stmt.hpp

Timestamp:

May 16, 2019, 2:57:41 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

b336af9

Parents:

10248ae0 (diff), f3cc5b6 (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

File:

• src/AST/Stmt.hpp (modified) (25 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 {
 
@@ -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 auto 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 auto 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 auto 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 auto 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 auto 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 auto 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 auto 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 auto 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 auto 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 auto 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 auto 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 auto 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 auto 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 auto 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 auto 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 auto 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 auto 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 auto 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 auto 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 auto 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
 };
 
@@ -510 +454 @@
 }
 
+#undef MUTATE_FRIEND
+
 // Local Variables: //
 // tab-width: 4 //