Changeset a554e5f4 for src/AST

Timestamp:

Feb 9, 2022, 3:33:42 PM (4 years ago)

Author:

caparsons <caparson@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, master, pthread-emulation, qualifiedEnum

Children:

850aff1

Parents:

21a99cc (diff), c4f81702 (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:

• Pass.hpp (modified) (1 diff)
• Pass.impl.hpp (modified) (18 diffs)
• Stmt.cpp (modified) (2 diffs)
• Stmt.hpp (modified) (20 diffs)

src/AST/Pass.hpp

@@ -238 +238 @@
 
 private:
-        const ast::Stmt * call_accept( const ast::Stmt * );
-        const ast::Expr * call_accept( const ast::Expr * );
-
-        // requests WithStmtsToAdd directly add to this statement, as if it is a compound.
-
-        const ast::Stmt * call_accept_as_compound(const ast::Stmt *);
-
+
+        // Regular nodes
         template< typename node_t >
-        auto call_accept( const node_t * node ) -> typename std::enable_if<
+        struct result1 {
+                bool differs;
+                const node_t * value;
+
+                template< typename object_t, typename super_t, typename field_t >
+                void apply(object_t *, field_t super_t::* field);
+        };
+
+        result1<ast::Stmt> call_accept( const ast::Stmt * );
+        result1<ast::Expr> call_accept( const ast::Expr * );
+
+        template< typename node_t >
+        auto call_accept( const node_t * node )
+                -> typename std::enable_if<
                                 !std::is_base_of<ast::Expr, node_t>::value &&
                                 !std::is_base_of<ast::Stmt, node_t>::value
-                        , decltype( node->accept(*this) )
+                        , result1<
+                                typename std::remove_pointer< decltype( node->accept(*this) ) >::type
+                        >
                 >::type;
 
+        // requests WithStmtsToAdd directly add to this statement, as if it is a compound.
+        result1<ast::Stmt> call_accept_as_compound(const ast::Stmt *);
+
+        // Container of statements
         template< template <class...> class container_t >
-        container_t< ptr<Stmt> > call_accept( const container_t< ptr<Stmt> > & );
-
+        struct resultNstmt {
+                struct delta {
+                        ptr<Stmt> nval;
+                        ssize_t old_idx;
+                        bool is_old;
+
+                        delta(const Stmt * s, ssize_t i, bool old) : nval{s}, old_idx{i}, is_old{old} {}
+                };
+
+                bool differs;
+                container_t< delta > values;
+
+                resultNstmt() : differs(false), values{} {}
+                resultNstmt(bool diff, container_t< delta > && vals) : differs(diff), values(vals) {}
+
+                template< typename object_t, typename super_t, typename field_t >
+                void apply(object_t *, field_t super_t::* field);
+
+                template< template <class...> class incontainer_t >
+                void take_all( incontainer_t<ast::ptr<ast::Stmt>> * stmts ) {
+                        if(!stmts || stmts->empty()) return;
+
+                        std::transform(stmts->begin(), stmts->end(), std::back_inserter( values ), [](ast::ptr<ast::Stmt>& decl) -> delta {
+                                        return delta( decl.release(), -1, false );
+                                });
+                        stmts->clear();
+                        differs = true;
+                }
+
+                template< template <class...> class incontainer_t >
+                void take_all( incontainer_t<ast::ptr<ast::Decl>> * decls ) {
+                        if(!decls || decls->empty()) return;
+
+                        std::transform(decls->begin(), decls->end(), std::back_inserter( values ), [](ast::ptr<ast::Decl>& decl) -> auto {
+                                        auto loc = decl->location;
+                                        auto stmt = new DeclStmt( loc, decl.release() );
+                                        return delta( stmt, -1, false );
+                                });
+                        decls->clear();
+                        differs = true;
+                }
+        };
+
+        template< template <class...> class container_t >
+        resultNstmt<container_t> call_accept( const container_t< ptr<Stmt> > & );
+
+        // Container of something
         template< template <class...> class container_t, typename node_t >
-        container_t< ptr<node_t> > call_accept( const container_t< ptr<node_t> > & container );
+        struct resultN {
+                bool differs;
+                container_t<ptr<node_t>> values;
+
+                template< typename object_t, typename super_t, typename field_t >
+                void apply(object_t *, field_t super_t::* field);
+        };
+
+        template< template <class...> class container_t, typename node_t >
+        resultN< container_t, node_t > call_accept( const container_t< ptr<node_t> > & container );
 
 public:
         /// Logic to call the accept and mutate the parent if needed, delegates call to accept
-        template<typename node_t, typename parent_t, typename child_t>
-        void maybe_accept(const node_t * &, child_t parent_t::* child);
-
-        template<typename node_t, typename parent_t, typename child_t>
-        void maybe_accept_as_compound(const node_t * &, child_t parent_t::* child);
+        template<typename node_t, typename parent_t, typename field_t>
+        void maybe_accept(const node_t * &, field_t parent_t::* field);
+
+        template<typename node_t, typename parent_t, typename field_t>
+        void maybe_accept_as_compound(const node_t * &, field_t parent_t::* field);
 
 private:

src/AST/Pass.impl.hpp

@@ -79 +79 @@
 
                 template<typename it_t, template <class...> class container_t>
-                static inline void take_all( it_t it, container_t<ast::ptr<ast::Stmt>> * decls, bool * mutated = nullptr ) {
-                        if(empty(decls)) return;
-
-                        std::move(decls->begin(), decls->end(), it);
-                        decls->clear();
+                static inline void take_all( it_t it, container_t<ast::ptr<ast::Stmt>> * stmts, bool * mutated = nullptr ) {
+                        if(empty(stmts)) return;
+
+                        std::move(stmts->begin(), stmts->end(), it);
+                        stmts->clear();
                         if(mutated) *mutated = true;
                 }
@@ -123 +123 @@
                         return !new_val.empty();
                 }
+        }
+
+
+        template< typename core_t >
+        template< typename node_t >
+        template< typename object_t, typename super_t, typename field_t >
+        void ast::Pass< core_t >::result1< node_t >::apply(object_t * object, field_t super_t::* field) {
+                object->*field = value;
         }
 
@@ -131 +139 @@
                                 !std::is_base_of<ast::Expr, node_t>::value &&
                                 !std::is_base_of<ast::Stmt, node_t>::value
-                        , decltype( node->accept(*this) )
+                        , ast::Pass< core_t >::result1<
+                                typename std::remove_pointer< decltype( node->accept(*this) ) >::type
+                        >
                 >::type
         {
@@ -140 +150 @@
                 static_assert( !std::is_base_of<ast::Stmt, node_t>::value, "ERROR");
 
-                return node->accept( *this );
+                auto nval = node->accept( *this );
+                ast::Pass< core_t >::result1<
+                        typename std::remove_pointer< decltype( node->accept(*this) ) >::type
+                > res;
+                res.differs = nval != node;
+                res.value = nval;
+                return res;
         }
 
         template< typename core_t >
-        const ast::Expr * ast::Pass< core_t >::call_accept( const ast::Expr * expr ) {
+        typename ast::Pass< core_t >::template result1<ast::Expr> ast::Pass< core_t >::call_accept( const ast::Expr * expr ) {
                 __pedantic_pass_assert( __visit_children() );
                 __pedantic_pass_assert( expr );
@@ -153 +169 @@
                 }
 
-                return expr->accept( *this );
+                auto nval = expr->accept( *this );
+                return { nval != expr, nval };
         }
 
         template< typename core_t >
-        const ast::Stmt * ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) {
+        typename ast::Pass< core_t >::template result1<ast::Stmt> ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) {
                 __pedantic_pass_assert( __visit_children() );
                 __pedantic_pass_assert( stmt );
 
-                return stmt->accept( *this );
+                const ast::Stmt * nval = stmt->accept( *this );
+                return { nval != stmt, nval };
         }
 
         template< typename core_t >
-        const ast::Stmt * ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
+        typename ast::Pass< core_t >::template result1<ast::Stmt> ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
                 __pedantic_pass_assert( __visit_children() );
                 __pedantic_pass_assert( stmt );
@@ -190 +208 @@
                 // If the pass doesn't want to add anything then we are done
                 if( empty(stmts_before) && empty(stmts_after) && empty(decls_before) && empty(decls_after) ) {
-                        return nstmt;
+                        return { nstmt != stmt, nstmt };
                 }
 
@@ -212 +230 @@
                 __pass::take_all( std::back_inserter( compound->kids ), stmts_after );
 
-                return compound;
+                return {true, compound};
         }
 
         template< typename core_t >
         template< template <class...> class container_t >
-        container_t< ptr<Stmt> > ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
+        template< typename object_t, typename super_t, typename field_t >
+        void ast::Pass< core_t >::resultNstmt<container_t>::apply(object_t * object, field_t super_t::* field) {
+                auto & container = object->*field;
+                __pedantic_pass_assert( container.size() <= values.size() );
+
+                auto cit = enumerate(container).begin();
+
+                container_t<ptr<Stmt>> nvals;
+                for(delta & d : values) {
+                        if( d.is_old ) {
+                                __pedantic_pass_assert( cit.idx <= d.old_idx );
+                                std::advance( cit, d.old_idx - cit.idx );
+                                nvals.push_back( std::move( (*cit).val) );
+                        } else {
+                                nvals.push_back( std::move(d.nval) );
+                        }
+                }
+
+                object->*field = std::move(nvals);
+        }
+
+        template< typename core_t >
+        template< template <class...> class container_t >
+        typename ast::Pass< core_t >::template resultNstmt<container_t> ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
                 __pedantic_pass_assert( __visit_children() );
                 if( statements.empty() ) return {};
@@ -244 +285 @@
                 pass_visitor_stats.avg->push(pass_visitor_stats.depth);
 
-                bool mutated = false;
-                container_t< ptr<Stmt> > new_kids;
-                for( const Stmt * stmt : statements ) {
+                resultNstmt<container_t> new_kids;
+                for( auto value : enumerate( statements ) ) {
                         try {
+                                size_t i = value.idx;
+                                const Stmt * stmt = value.val;
                                 __pedantic_pass_assert( stmt );
                                 const ast::Stmt * new_stmt = stmt->accept( *this );
                                 assert( new_stmt );
-                                if(new_stmt != stmt ) mutated = true;
+                                if(new_stmt != stmt ) { new_kids.differs = true; }
 
                                 // Make sure that it is either adding statements or declartions but not both
@@ -261 +303 @@
 
                                 // Take all the statements which should have gone after, N/A for first iteration
-                                __pass::take_all( std::back_inserter( new_kids ), decls_before, &mutated );
-                                __pass::take_all( std::back_inserter( new_kids ), stmts_before, &mutated );
+                                new_kids.take_all( decls_before );
+                                new_kids.take_all( stmts_before );
 
                                 // Now add the statement if there is one
-                                new_kids.emplace_back( new_stmt );
+                                if(new_stmt != stmt) {
+                                        new_kids.values.emplace_back( new_stmt, i, false );
+                                } else {
+                                        new_kids.values.emplace_back( nullptr, i, true );
+                                }
 
                                 // Take all the declarations that go before
-                                __pass::take_all( std::back_inserter( new_kids ), decls_after, &mutated );
-                                __pass::take_all( std::back_inserter( new_kids ), stmts_after, &mutated );
+                                new_kids.take_all( decls_after );
+                                new_kids.take_all( stmts_after );
                         }
                         catch ( SemanticErrorException &e ) {
@@ -278 +324 @@
                 if ( !errors.isEmpty() ) { throw errors; }
 
-                return mutated ? new_kids : container_t< ptr<Stmt> >();
+                return new_kids;
         }
 
         template< typename core_t >
         template< template <class...> class container_t, typename node_t >
-        container_t< ast::ptr<node_t> > ast::Pass< core_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
+        template< typename object_t, typename super_t, typename field_t >
+        void ast::Pass< core_t >::resultN<container_t, node_t>::apply(object_t * object, field_t super_t::* field) {
+                auto & container = object->*field;
+                __pedantic_pass_assert( container.size() == values.size() );
+
+                for(size_t i = 0; i < container.size(); i++) {
+                        // Take all the elements that are different in 'values'
+                        // and swap them into 'container'
+                        if( values[i] != nullptr ) std::swap(container[i], values[i]);
+                }
+
+                // Now the original containers should still have the unchanged values
+                // but also contain the new values
+        }
+
+        template< typename core_t >
+        template< template <class...> class container_t, typename node_t >
+        typename ast::Pass< core_t >::template resultN<container_t, node_t> ast::Pass< core_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
                 __pedantic_pass_assert( __visit_children() );
                 if( container.empty() ) return {};
@@ -293 +356 @@
 
                 bool mutated = false;
-                container_t< ast::ptr<node_t> > new_kids;
+                container_t<ptr<node_t>> new_kids;
                 for ( const node_t * node : container ) {
                         try {
                                 __pedantic_pass_assert( node );
                                 const node_t * new_stmt = strict_dynamic_cast< const node_t * >( node->accept( *this ) );
-                                if(new_stmt != node ) mutated = true;
-
-                                new_kids.emplace_back( new_stmt );
+                                if(new_stmt != node ) {
+                                        mutated = true;
+                                        new_kids.emplace_back( new_stmt );
+                                } else {
+                                        new_kids.emplace_back( nullptr );
+                                }
+
                         }
                         catch( SemanticErrorException &e ) {
@@ -306 +373 @@
                         }
                 }
+
+                __pedantic_pass_assert( new_kids.size() == container.size() );
                 pass_visitor_stats.depth--;
                 if ( ! errors.isEmpty() ) { throw errors; }
 
-                return mutated ? new_kids : container_t< ast::ptr<node_t> >();
+                return ast::Pass< core_t >::resultN<container_t, node_t>{ mutated,  new_kids };
         }
 
@@ -327 +396 @@
                 auto new_val = call_accept( old_val );
 
-                static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR");
-
-                if( __pass::differs(old_val, new_val) ) {
+                static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value /* || std::is_same<int, decltype(old_val)>::value */, "ERROR");
+
+                if( new_val.differs ) {
                         auto new_parent = __pass::mutate<core_t>(parent);
-                        new_parent->*child = new_val;
+                        new_val.apply(new_parent, child);
                         parent = new_parent;
                 }
@@ -353 +422 @@
                 static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR");
 
-                if( __pass::differs(old_val, new_val) ) {
+                if( new_val.differs ) {
                         auto new_parent = __pass::mutate<core_t>(parent);
-                        new_parent->*child = new_val;
+                        new_val.apply( new_parent, child );
                         parent = new_parent;
                 }
@@ -941 +1010 @@
                         const Expr * func = clause.target.func ? clause.target.func->accept(*this) : nullptr;
                         if(func != clause.target.func) mutated = true;
+                        else func = nullptr;
 
                         std::vector<ptr<Expr>> new_args;
@@ -946 +1016 @@
                         for( const auto & arg : clause.target.args ) {
                                 auto a = arg->accept(*this);
-                                new_args.push_back( a );
-                                if( a != arg ) mutated = true;
+                                if( a != arg ) {
+                                        mutated = true;
+                                        new_args.push_back( a );
+                                } else
+                                        new_args.push_back( nullptr );
                         }
 
                         const Stmt * stmt = clause.stmt ? clause.stmt->accept(*this) : nullptr;
                         if(stmt != clause.stmt) mutated = true;
+                        else stmt = nullptr;
 
                         const Expr * cond = clause.cond ? clause.cond->accept(*this) : nullptr;
                         if(cond != clause.cond) mutated = true;
+                        else cond = nullptr;
 
                         new_clauses.push_back( WaitForStmt::Clause{ {func, std::move(new_args) }, stmt, cond } );
@@ -961 +1036 @@
                 if(mutated) {
                         auto n = __pass::mutate<core_t>(node);
-                        n->clauses = std::move( new_clauses );
+                        for(size_t i = 0; i < new_clauses.size(); i++) {
+                                if(new_clauses.at(i).target.func != nullptr) std::swap(n->clauses.at(i).target.func, new_clauses.at(i).target.func);
+
+                                for(size_t j = 0; j < new_clauses.at(i).target.args.size(); j++) {
+                                        if(new_clauses.at(i).target.args.at(j) != nullptr) std::swap(n->clauses.at(i).target.args.at(j), new_clauses.at(i).target.args.at(j));
+                                }
+
+                                if(new_clauses.at(i).stmt != nullptr) std::swap(n->clauses.at(i).stmt, new_clauses.at(i).stmt);
+                                if(new_clauses.at(i).cond != nullptr) std::swap(n->clauses.at(i).cond, new_clauses.at(i).cond);
+                        }
                         node = n;
                 }
@@ -969 +1053 @@
                 if(node->field) { \
                         auto nval = call_accept( node->field ); \
-                        if(nval != node->field ) { \
+                        if(nval.differs ) { \
                                 auto nparent = __pass::mutate<core_t>(node); \
-                                nparent->field = nval; \
+                                nparent->field = nval.value; \
                                 node = nparent; \
                         } \

src/AST/Stmt.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed May  8 13:00:00 2019
-// Last Modified By : Andrew Beach
-// Last Modified On : Wed May 15 15:53:00 2019
-// Update Count     : 2
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Feb  2 19:01:20 2022
+// Update Count     : 3
 //
 
@@ -56 +56 @@
 
 // --- BranchStmt
-BranchStmt::BranchStmt( const CodeLocation& loc, Kind kind, Label target, std::vector<Label>&& labels )
-: Stmt(loc, std::move(labels)), originalTarget(target), target(target), kind(kind) {
+BranchStmt::BranchStmt( const CodeLocation& loc, Kind kind, Label target, const std::vector<Label>&& labels )
+                : Stmt(loc, std::move(labels)), originalTarget(target), target(target), kind(kind) {
         // Make sure a syntax error hasn't slipped through.
         assert( Goto != kind || !target.empty() );

src/AST/Stmt.hpp

@@ -10 +10 @@
 // Created On       : Wed May  8 13:00:00 2019
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  1 17:44:46 2022
-// Update Count     : 24
+// Last Modified On : Wed Feb  2 20:06:41 2022
+// Update Count     : 34
 //
 
@@ -39 +39 @@
         std::vector<Label> labels;
 
-        Stmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
+        Stmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
                 : ParseNode(loc), labels(std::move(labels)) {}
 
@@ -55 +55 @@
         std::list<ptr<Stmt>> kids;
 
-        CompoundStmt(const CodeLocation & loc, std::list<ptr<Stmt>> && ks = {},
-                                 std::vector<Label> && labels = {} )
+        CompoundStmt(const CodeLocation & loc, const std::list<ptr<Stmt>> && ks = {}, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), kids(std::move(ks)) {}
 
@@ -74 +73 @@
 class NullStmt final : public Stmt {
   public:
-        NullStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
+        NullStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)) {}
 
@@ -88 +87 @@
         ptr<Expr> expr;
 
-        ExprStmt( const CodeLocation & loc, const Expr* e, std::vector<Label> && labels = {} )
+        ExprStmt( const CodeLocation & loc, const Expr* e, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), expr(e) {}
 
@@ -107 +106 @@
 
         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 = {})
+                         const std::vector<ptr<Expr>> && output, const std::vector<ptr<Expr>> && input,
+                         const std::vector<ptr<ConstantExpr>> && clobber, const std::vector<Label> && gotoLabels,
+                         const 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)),
@@ -144 +143 @@
 
         IfStmt( const CodeLocation & loc, const Expr * cond, const Stmt * then,
-                        const Stmt * else_ = nullptr, std::vector<ptr<Stmt>> && inits = {},
-                        std::vector<Label> && labels = {} )
+                        const Stmt * else_ = nullptr, const std::vector<ptr<Stmt>> && inits = {},
+                        const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), then(then), else_(else_),
                   inits(std::move(inits)) {}
@@ -161 +160 @@
         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, const std::vector<ptr<Stmt>> && stmts,
+                                const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
 
@@ -178 +177 @@
         std::vector<ptr<Stmt>> stmts;
 
-        CaseStmt( const CodeLocation & loc, const Expr * cond, std::vector<ptr<Stmt>> && stmts,
-                          std::vector<Label> && labels = {} )
+        CaseStmt( const CodeLocation & loc, const Expr * cond, const std::vector<ptr<Stmt>> && stmts,
+                          const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
 
@@ -200 +199 @@
 
         WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
-                           std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, std::vector<Label> && labels = {} )
+                                 const std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(nullptr), inits(std::move(inits)), isDoWhile(isDoWhile) {}
 
         WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body, const Stmt * else_,
-                           std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, std::vector<Label> && labels = {} )
+                                 const std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(else_), inits(std::move(inits)), isDoWhile(isDoWhile) {}
 
@@ -222 +221 @@
         ptr<Stmt> else_;
 
-        ForStmt( const CodeLocation & loc, std::vector<ptr<Stmt>> && inits, const Expr * cond,
-                         const Expr * inc, const Stmt * body, std::vector<Label> && label = {} )
+        ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
+                         const Expr * inc, const Stmt * body, const std::vector<Label> && label = {} )
                 : Stmt(loc, std::move(label)), inits(std::move(inits)), cond(cond), inc(inc), body(body), else_(nullptr) {}
 
-        ForStmt( const CodeLocation & loc, std::vector<ptr<Stmt>> && inits, const Expr * cond,
-                         const Expr * inc, const Stmt * body, const Stmt * else_, std::vector<Label> && labels = {} )
+        ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
+                         const Expr * inc, const Stmt * body, const Stmt * else_, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc), body(body), else_(else_) {}
 
@@ -247 +246 @@
         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 = {} )
-                : Stmt(loc, std::move(labels)), originalTarget(loc), target(loc),
-                  computedTarget(computedTarget), kind(Goto) {}
+        BranchStmt( const CodeLocation & loc, Kind kind, Label target, const std::vector<Label> && labels = {} );
+        BranchStmt( const CodeLocation & loc, const Expr * computedTarget, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), originalTarget(loc), target(loc), computedTarget(computedTarget), kind(Goto) {}
 
         const char * kindName() const { return kindNames[kind]; }
@@ -269 +265 @@
         ptr<Expr> expr;
 
-        ReturnStmt( const CodeLocation & loc, const Expr * expr, std::vector<Label> && labels = {} )
+        ReturnStmt( const CodeLocation & loc, const Expr * expr, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), expr(expr) {}
 
@@ -288 +284 @@
         ExceptionKind kind;
 
-        ThrowStmt(
-                const CodeLocation & loc, ExceptionKind kind, const Expr * expr, const Expr * target,
-                std::vector<Label> && labels = {} )
+        ThrowStmt( const CodeLocation & loc, ExceptionKind kind, const Expr * expr,
+                           const Expr * target, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), expr(expr), target(target), kind(kind) {}
 
@@ -306 +301 @@
         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,
+                         const std::vector<ptr<CatchStmt>> && handlers, const FinallyStmt * finally,
+                         const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}
 
@@ -326 +320 @@
         ExceptionKind kind;
 
-        CatchStmt(
-                const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
-                const Stmt * body, std::vector<Label> && labels = {} )
+        CatchStmt( const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
+                           const Stmt * body, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), decl(decl), cond(cond), body(body), kind(kind) {}
 
@@ -358 +351 @@
         enum Type { None, Coroutine, Generator } type = None;
 
-        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, std::vector<Label> && labels = {} )
+        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), then(then), type(type) {}
 
@@ -396 +389 @@
         OrElse orElse;
 
-        WaitForStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
+        WaitForStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)) {}
 
@@ -410 +403 @@
         ptr<Decl> decl;
 
-        DeclStmt( const CodeLocation & loc, const Decl * decl, std::vector<Label> && labels = {} )
+        DeclStmt( const CodeLocation & loc, const Decl * decl, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), decl(decl) {}
 
@@ -441 +434 @@
 
         MutexStmt( const CodeLocation & loc, const Stmt * stmt, 
-                           std::vector<ptr<Expr>> && mutexes, std::vector<Label> && labels = {} )
+                           const std::vector<ptr<Expr>> && mutexes, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}