Changeset 246c245

Timestamp:

May 16, 2019, 6:51:18 PM (4 years ago)

Author:

Aaron Moss <a3moss@…>

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:

8ff178d, d66e7b7

Parents:

9b4f329 (diff), 6f8e87d (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

Files:

• libcfa/src/concurrency/coroutine.hfa (modified) (1 diff)
• src/AST/Attribute.hpp (modified) (1 diff)
• src/AST/Convert.cpp (modified) (9 diffs)
• src/AST/Decl.cpp (modified) (3 diffs)
• src/AST/Decl.hpp (modified) (2 diffs)
• src/AST/Expr.cpp (modified) (12 diffs)
• src/AST/Expr.hpp (modified) (7 diffs)
• src/AST/Fwd.hpp (modified) (1 diff)
• src/AST/Init.cpp (modified) (2 diffs)
• src/AST/Init.hpp (modified) (3 diffs)
• src/AST/LinkageSpec.cpp (modified) (1 diff)
• src/AST/Node.cpp (added)
• src/AST/Node.hpp (modified) (7 diffs)
• src/AST/ParseNode.hpp (modified) (1 diff)
• src/AST/Pass.hpp (modified) (1 diff)
• src/AST/Pass.impl.hpp (modified) (8 diffs)
• src/AST/Pass.proto.hpp (modified) (2 diffs)
• src/AST/Stmt.cpp (modified) (2 diffs)
• src/AST/Stmt.hpp (modified) (4 diffs)
• src/AST/Type.cpp (modified) (7 diffs)
• src/AST/Type.hpp (modified) (19 diffs)
• src/AST/TypeSubstitution.cpp (added)
• src/AST/TypeSubstitution.hpp (added)
• src/AST/porting.md (modified) (1 diff)
• src/Common/utility.h (modified) (1 diff)
• src/Parser/ExpressionNode.cc (modified) (2 diffs)
• src/SynTree/SynTree.h (modified) (1 diff)

libcfa/src/concurrency/coroutine.hfa

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

src/AST/Attribute.hpp

@@ -50 +50 @@
         /// Must be copied in ALL derived classes
         template<typename node_t>
-        friend auto mutate(const node_t * node);
+        friend node_t * mutate(const node_t * node);
 };
 
-
-
-//=================================================================================================
-/// This disgusting and giant piece of boiler-plate is here to solve a cyclic dependency
-/// remove only if there is a better solution
-/// The problem is that ast::ptr< ... > uses increment/decrement which won't work well with
-/// forward declarations
-inline void increment( const class Attribute * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class Attribute * node, Node::ref_type ref ) { node->decrement( ref ); }
 }
 

src/AST/Convert.cpp

@@ -9 +9 @@
 // Author           : Thierry Delisle
 // Created On       : Thu May 09 15::37::05 2019
-// Last Modified By :
-// Last Modified On :
-// Update Count     :
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu May 16 17:21:00 2019
+// Update Count     : 1
 //
 
@@ -74 +74 @@
         ast::Node * node;
 
+        // Local Utilities:
+
+        template<typename NewT, typename OldT>
+        NewT * getAccept1( OldT old ) {
+                old->accept(*this);
+                return strict_dynamic_cast< NewT * >( node );
+        }
+
+#       define GET_ACCEPT_1(child, type) \
+                getAccept1< ast::type, decltype( old->child ) >( old->child )
+
+        template<typename NewT, typename OldC>
+        std::vector< ast::ptr<NewT> > getAcceptV( OldC& old ) {
+                std::vector< ast::ptr<NewT> > ret;
+                ret.reserve( old.size() );
+                for ( auto a : old ) {
+                        a->accept( *this );
+                        ret.emplace_back( strict_dynamic_cast< NewT * >(node) );
+                }
+                return ret;
+        }
+
+#       define GET_ACCEPT_V(child, type) \
+                getAcceptV< ast::type, decltype( old->child ) >( old->child )
+
+        ast::Label make_label(Label* old) {
+                return ast::Label(
+                        old->labelled->location,
+                        old->name,
+                        GET_ACCEPT_V(attributes, Attribute)
+                );
+        }
+
         template<template <class...> class C>
         C<ast::Label> make_labels(C<Label> olds) {
                 C<ast::Label> ret;
-                for(auto oldn : olds) {
-                        auto old = &oldn; // to reuse the MACRO
-                        ACCEPT_N(attr, attributes, Attribute)
-                        ast::Label l(
-                                {},
-                                old->get_name(),
-                                to<std::vector>::from( std::move( attr ) )
-                        );
-                        ret.push_back( l );
+                for (auto oldn : olds) {
+                        ret.push_back( make_label( &oldn ) );
                 }
                 return ret;
         }
+
+#       define GET_LABELS_V(labels) \
+                to<std::vector>::from( make_labels( std::move( labels ) ) )
+
+        // Now all the visit functions:
 
         virtual void visit( ObjectDecl * old ) override final {
@@ -135 +166 @@
                 decl->parent = parent;
                 decl->body   = old->body;
-                decl->parameters = params;
+                decl->params = params;
                 decl->members    = members;
                 decl->extension  = old->extension;
@@ -158 +189 @@
                 decl->parent = parent;
                 decl->body   = old->body;
-                decl->parameters = params;
+                decl->params = params;
                 decl->members    = members;
                 decl->extension  = old->extension;
@@ -181 +212 @@
                 decl->parent = parent;
                 decl->body   = old->body;
-                decl->parameters = params;
+                decl->params = params;
                 decl->members    = members;
                 decl->extension  = old->extension;
@@ -204 +235 @@
                 decl->parent = parent;
                 decl->body   = old->body;
-                decl->parameters = params;
+                decl->params = params;
                 decl->members    = members;
                 decl->extension  = old->extension;
@@ -230 +261 @@
 
                 decl->assertions = asserts;
-                decl->parameters = params;
+                decl->params     = params;
                 decl->extension  = old->extension;
                 decl->uniqueId   = old->uniqueId;
@@ -258 +289 @@
 
         virtual void visit( ExprStmt * old ) override final {
-                ACCEPT_1(expr, expr, Expr)
-                auto stmt = new ast::ExprStmt(
-                        old->location,
-                        expr
-                );
-                stmt->labels = to<std::vector>::from( make_labels( std::move( old->labels ) ) );
+                this->node = new ast::ExprStmt(
+                        old->location,
+                        GET_ACCEPT_1(expr, Expr),
+                        GET_LABELS_V(old->labels)
+                );
+        }
+
+        virtual void visit( AsmStmt * old ) override final {
+                this->node = new ast::AsmStmt(
+                        old->location,
+                        old->voltile,
+                        GET_ACCEPT_1(instruction, Expr),
+                        GET_ACCEPT_V(output, Expr),
+                        GET_ACCEPT_V(input, Expr),
+                        GET_ACCEPT_V(clobber, ConstantExpr),
+                        GET_LABELS_V(old->gotolabels),
+                        GET_LABELS_V(old->labels)
+                );
+        }
+
+        virtual void visit( DirectiveStmt * old ) override final {
+                this->node = new ast::DirectiveStmt(
+                        old->location,
+                        old->directive,
+                        GET_LABELS_V(old->labels)
+                );
+        }
+
+        virtual void visit( IfStmt * old ) override final {
+                this->node = new ast::IfStmt(
+                        old->location,
+                        GET_ACCEPT_1(condition, Expr),
+                        GET_ACCEPT_1(thenPart, Stmt),
+                        GET_ACCEPT_1(elsePart, Stmt),
+                        GET_ACCEPT_V(initialization, Stmt),
+                        GET_LABELS_V(old->labels)
+                );
+        }
+
+        virtual void visit( SwitchStmt * old ) override final {
+                this->node = new ast::SwitchStmt(
+                        old->location,
+                        GET_ACCEPT_1(condition, Expr),
+                        GET_ACCEPT_V(statements, Stmt),
+                        GET_LABELS_V(old->labels)
+                );
+        }
+
+        virtual void visit( CaseStmt * old ) override final {
+                this->node = new ast::CaseStmt(
+                        old->location,
+                        GET_ACCEPT_1(condition, Expr),
+                        GET_ACCEPT_V(stmts, Stmt),
+                        GET_LABELS_V(old->labels)
+                );
+        }
+
+        virtual void visit( WhileStmt * old ) override final {
+                this->node = new ast::WhileStmt(
+                        old->location,
+                        GET_ACCEPT_1(condition, Expr),
+                        GET_ACCEPT_1(body, Stmt),
+                        GET_ACCEPT_V(initialization, Stmt),
+                        old->isDoWhile,
+                        GET_LABELS_V(old->labels)
+                );
+        }
+
+        virtual void visit( ForStmt * old ) override final {
+                this->node = new ast::ForStmt(
+                        old->location,
+                        GET_ACCEPT_V(initialization, Stmt),
+                        GET_ACCEPT_1(condition, Expr),
+                        GET_ACCEPT_1(increment, Expr),
+                        GET_ACCEPT_1(body, Stmt),
+                        GET_LABELS_V(old->labels)
+                );
+        }
+
+        virtual void visit( BranchStmt * old ) override final {
+                if (old->computedTarget) {
+                        this->node = new ast::BranchStmt(
+                                old->location,
+                                GET_ACCEPT_1(computedTarget, Expr),
+                                GET_LABELS_V(old->labels)
+                        );
+                } else {
+                        ast::BranchStmt::Kind kind;
+                        switch (old->type) {
+                        #define CASE(n) \
+                        case BranchStmt::n: \
+                                kind = ast::BranchStmt::n; \
+                                break
+                        CASE(Goto);
+                        CASE(Break);
+                        CASE(Continue);
+                        CASE(FallThrough);
+                        CASE(FallThroughDefault);
+                        #undef CASE
+                        }
+
+                        Label label = old->originalTarget;
+                        auto stmt = new ast::BranchStmt(
+                                old->location,
+                                kind,
+                                make_label(&label),
+                                GET_LABELS_V(old->labels)
+                        );
+                        stmt->target = make_label(&old->target);
+                        this->node = stmt;
+                }
+        }
+
+        virtual void visit( ReturnStmt * old ) override final {
+                this->node = new ast::ReturnStmt(
+                        old->location,
+                        GET_ACCEPT_1(expr, Expr),
+                        GET_LABELS_V(old->labels)
+                );
+        }
+
+        virtual void visit( ThrowStmt * old ) override final {
+                ast::ThrowStmt::Kind kind;
+                switch (old->kind) {
+                case ThrowStmt::Terminate:
+                        kind = ast::ThrowStmt::Terminate;
+                        break;
+                case ThrowStmt::Resume:
+                        kind = ast::ThrowStmt::Resume;
+                        break;
+                }
+
+                this->node = new ast::ThrowStmt(
+                        old->location,
+                        kind,
+                        GET_ACCEPT_1(expr, Expr),
+                        GET_ACCEPT_1(target, Expr),
+                        GET_LABELS_V(old->labels)
+                );
+        }
+
+        virtual void visit( TryStmt * old ) override final {
+                this->node = new ast::TryStmt(
+                        old->location,
+                        GET_ACCEPT_1(block, CompoundStmt),
+                        GET_ACCEPT_V(handlers, CatchStmt),
+                        GET_ACCEPT_1(finallyBlock, FinallyStmt),
+                        GET_LABELS_V(old->labels)
+                );
+        }
+
+        virtual void visit( CatchStmt * old ) override final {
+                ast::CatchStmt::Kind kind;
+                switch (old->kind) {
+                case CatchStmt::Terminate:
+                        kind = ast::CatchStmt::Terminate;
+                        break;
+                case CatchStmt::Resume:
+                        kind = ast::CatchStmt::Resume;
+                        break;
+                }
+
+                this->node = new ast::CatchStmt(
+                        old->location,
+                        kind,
+                        GET_ACCEPT_1(decl, Decl),
+                        GET_ACCEPT_1(cond, Expr),
+                        GET_ACCEPT_1(body, Stmt),
+                        GET_LABELS_V(old->labels)
+                );
+        }
+
+        virtual void visit( FinallyStmt * old ) override final {
+                this->node = new ast::FinallyStmt(
+                        old->location,
+                        GET_ACCEPT_1(block, CompoundStmt),
+                        GET_LABELS_V(old->labels)
+                );
+        }
+
+        virtual void visit( WaitForStmt * old ) override final {
+                ast::WaitForStmt * stmt = new ast::WaitForStmt(
+                        old->location,
+                        GET_LABELS_V(old->labels)
+                );
+
+                stmt->clauses.reserve( old->clauses.size() );
+                for (size_t i = 0 ; i < old->clauses.size() ; ++i) {
+                        stmt->clauses.push_back({
+                                ast::WaitForStmt::Target{
+                                        GET_ACCEPT_1(clauses[i].target.function, Expr),
+                                        GET_ACCEPT_V(clauses[i].target.arguments, Expr)
+                                },
+                                GET_ACCEPT_1(clauses[i].statement, Stmt),
+                                GET_ACCEPT_1(clauses[i].condition, Expr)
+                        });
+                }
+                stmt->timeout = {
+                        GET_ACCEPT_1(timeout.time, Expr),
+                        GET_ACCEPT_1(timeout.statement, Stmt),
+                        GET_ACCEPT_1(timeout.condition, Expr),
+                };
+                stmt->orElse = {
+                        GET_ACCEPT_1(timeout.statement, Stmt),
+                        GET_ACCEPT_1(timeout.condition, Expr),
+                };
 
                 this->node = stmt;
         }
 
-        virtual void visit( AsmStmt * ) override final {
-
-        }
-
-        virtual void visit( DirectiveStmt * ) override final {
-
-        }
-
-        virtual void visit( IfStmt * ) override final {
-
-        }
-
-        virtual void visit( WhileStmt * ) override final {
-
-        }
-
-        virtual void visit( ForStmt * ) override final {
-
-        }
-
-        virtual void visit( SwitchStmt * ) override final {
-
-        }
-
-        virtual void visit( CaseStmt * ) override final {
-
-        }
-
-        virtual void visit( BranchStmt * ) override final {
-
-        }
-
-        virtual void visit( ReturnStmt * ) override final {
-
-        }
-
-        virtual void visit( ThrowStmt * ) override final {
-
-        }
-
-        virtual void visit( TryStmt * ) override final {
-
-        }
-
-        virtual void visit( CatchStmt * ) override final {
-
-        }
-
-        virtual void visit( FinallyStmt * ) override final {
-
-        }
-
-        virtual void visit( WaitForStmt * ) override final {
-
-        }
-
-        virtual void visit( WithStmt * ) override final {
-
+        virtual void visit( WithStmt * old ) override final {
+                this->node = new ast::WithStmt(
+                        old->location,
+                        GET_ACCEPT_V(exprs, Expr),
+                        GET_ACCEPT_1(stmt, Stmt),
+                        GET_LABELS_V(old->labels)
+                );
         }
 
         virtual void visit( NullStmt * old ) override final {
-                auto stmt = new ast::NullStmt(
-                        old->location,
-                        to<std::vector>::from( make_labels( std::move( old->labels ) ) )
-                );
-
-                this->node = stmt;
-        }
-
-        virtual void visit( DeclStmt * ) override final {
-
-        }
-
-        virtual void visit( ImplicitCtorDtorStmt * ) override final {
-
+                this->node = new ast::NullStmt(
+                        old->location,
+                        GET_LABELS_V(old->labels)
+                );
+        }
+
+        virtual void visit( DeclStmt * old ) override final {
+                this->node = new ast::DeclStmt(
+                        old->location,
+                        GET_ACCEPT_1(decl, Decl),
+                        GET_LABELS_V(old->labels)
+                );
+        }
+
+        virtual void visit( ImplicitCtorDtorStmt * old ) override final {
+                this->node = new ast::ImplicitCtorDtorStmt(
+                        old->location,
+                        GET_ACCEPT_1(callStmt, Stmt),
+                        GET_LABELS_V(old->labels)
+                );
         }
 
@@ -592 +778 @@
 
         }
+
+        virtual void visit( AttrExpr * ) override final {
+
+                assert( 0 );
+        }
 };
+
+#undef GET_LABELS_V
+#undef GET_ACCEPT_V
+#undef GET_ACCEPT_1
 
 #undef ACCEPT_N

src/AST/Decl.cpp

@@ -20 +20 @@
 #include <unordered_map>
 
+#include "Common/utility.h"
+
 #include "Fwd.hpp"             // for UniqueId
 #include "Init.hpp"
 #include "Node.hpp"            // for readonly
+#include "Type.hpp"            // for readonly
 #include "Parser/ParseNode.h"  // for DeclarationNode
 
@@ -47 +50 @@
 // --- FunctionDecl
 
-const Type * FunctionDecl::get_type() const override { return type.get(); }
-void FunctionDecl::set_type(Type * t) override { type = strict_dynamic_cast< FunctionType* >( t ); }
+const Type * FunctionDecl::get_type() const { return type.get(); }
+void FunctionDecl::set_type(Type * t) { type = strict_dynamic_cast< FunctionType* >( t ); }
 
 // --- TypeDecl
@@ -75 +78 @@
                         const ObjectDecl* field = strict_dynamic_cast< const ObjectDecl* >( member );
                         if ( field->init ) {
-                                const SingleInit* init = strict_dynamic_cast< const SingleInit* >( field->init );
+                                const SingleInit * init = strict_dynamic_cast< const SingleInit* >( field->init.get() );
                                 auto result = eval( init->value );
                                 if ( ! result.second ) {

src/AST/Decl.hpp

@@ -31 +31 @@
 
 // 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);
+#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
 
 namespace ast {
@@ -341 +341 @@
 };
 
-//=================================================================================================
-/// This disgusting and giant piece of boiler-plate is here to solve a cyclic dependency
-/// remove only if there is a better solution
-/// The problem is that ast::ptr< ... > uses increment/decrement which won't work well with
-/// forward declarations
-inline void increment( const class Decl * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class Decl * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class DeclWithType * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class DeclWithType * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class ObjectDecl * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class ObjectDecl * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class FunctionDecl * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class FunctionDecl * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class AggregateDecl * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class AggregateDecl * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class StructDecl * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class StructDecl * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class UnionDecl * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class UnionDecl * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class EnumDecl * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class EnumDecl * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class TraitDecl * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class TraitDecl * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class NamedTypeDecl * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class NamedTypeDecl * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class TypeDecl * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class TypeDecl * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class TypedefDecl * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class TypedefDecl * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class AsmDecl * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class AsmDecl * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class StaticAssertDecl * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class StaticAssertDecl * node, Node::ref_type ref ) { node->decrement(ref); }
-
 }
 

src/AST/Expr.cpp

@@ -32 +32 @@
 // --- ApplicationExpr
 
-ApplicationExpr::ApplicationExpr( const CodeLocation & loc, const Expr * f, 
-        std::vector<ptr<Expr>> && as ) 
-: Expr( loc ), func( f ), args( std::move(args) ) {
+ApplicationExpr::ApplicationExpr( const CodeLocation & loc, const Expr * f,
+        std::vector<ptr<Expr>> && as )
+: Expr( loc ), func( f ), args( std::move(as) ) {
         // ensure that `ApplicationExpr` result type is `FuncExpr`
         const PointerType * pt = strict_dynamic_cast< const PointerType * >( f->result.get() );
@@ -48 +48 @@
         assert( arg );
 
-        UntypedExpr * ret = new UntypedExpr{ 
-                loc, new NameExpr{loc, "*?"}, std::vector<ptr<Expr>>{ ptr<Expr>{ arg } } 
+        UntypedExpr * ret = new UntypedExpr{
+                loc, new NameExpr{loc, "*?"}, std::vector<ptr<Expr>>{ ptr<Expr>{ arg } }
         };
         if ( const Type * ty = arg->result ) {
@@ -59 +59 @@
                         ret->result = new ReferenceType{ base };
                 } else {
-                        // references have been removed, in which case dereference returns an lvalue of the 
+                        // references have been removed, in which case dereference returns an lvalue of the
                         // base type
                         ret->result.set_and_mutate( base )->set_lvalue( true );
@@ -112 +112 @@
                 } else {
                         // taking address of non-lvalue, must be a reference, loses one layer of reference
-                        if ( const ReferenceType * refType = 
+                        if ( const ReferenceType * refType =
                                         dynamic_cast< const ReferenceType * >( arg->result.get() ) ) {
                                 Type * res = addrType( refType->base );
@@ -118 +118 @@
                                 result = res;
                         } else {
-                                SemanticError( loc, arg->result, 
+                                SemanticError( loc, arg->result,
                                         "Attempt to take address of non-lvalue expression: " );
                         }
@@ -128 +128 @@
 
 // label address always has type `void*`
-LabelAddressExpr::LabelAddressExpr( const CodeLocation & loc, Label && a ) 
+LabelAddressExpr::LabelAddressExpr( const CodeLocation & loc, Label && a )
 : Expr( loc, new PointerType{ new VoidType{} } ), arg( a ) {}
 
 // --- CastExpr
 
-CastExpr::CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g ) 
+CastExpr::CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g )
 : Expr( loc, new VoidType{} ), arg( a ), isGenerated( g ) {}
 
@@ -169 +169 @@
 }
 
-VariableExpr * VariableExpr::functionPointer( 
+VariableExpr * VariableExpr::functionPointer(
                 const CodeLocation & loc, const FunctionDecl * decl ) {
         // wrap usually-determined result type in a pointer
@@ -202 +202 @@
 
 ConstantExpr * ConstantExpr::from_bool( const CodeLocation & loc, bool b ) {
-        return new ConstantExpr{ 
+        return new ConstantExpr{
                 loc, new BasicType{ BasicType::Bool }, b ? "1" : "0", (unsigned long long)b };
 }
 
 ConstantExpr * ConstantExpr::from_char( const CodeLocation & loc, char c ) {
-        return new ConstantExpr{ 
+        return new ConstantExpr{
                 loc, new BasicType{ BasicType::Char }, std::to_string( c ), (unsigned long long)c };
 }
 
 ConstantExpr * ConstantExpr::from_int( const CodeLocation & loc, int i ) {
-        return new ConstantExpr{ 
+        return new ConstantExpr{
                 loc, new BasicType{ BasicType::SignedInt }, std::to_string( i ), (unsigned long long)i };
 }
 
 ConstantExpr * ConstantExpr::from_ulong( const CodeLocation & loc, unsigned long i ) {
-        return new ConstantExpr{ 
-                loc, new BasicType{ BasicType::LongUnsignedInt }, std::to_string( i ), 
+        return new ConstantExpr{
+                loc, new BasicType{ BasicType::LongUnsignedInt }, std::to_string( i ),
                 (unsigned long long)i };
 }
@@ -229 +229 @@
         return new ConstantExpr{
                 loc,
-                new ArrayType{ 
+                new ArrayType{
                         new BasicType{ BasicType::Char, CV::Const },
                         ConstantExpr::from_int( loc, s.size() + 1 /* null terminator */ ),
@@ -258 +258 @@
 : Expr( loc, new BasicType{ BasicType::LongUnsignedInt } ), expr( nullptr ), type( t ) {}
 
-// --- UntypedOffsetofExpr
-
-UntypedOffsetofExpr::UntypedOffsetofExpr( 
-        const CodeLocation & loc, const Type * ty, const std::string & mem )
-: Expr( loc, new BasicType{ BasicType::LongUnsignedInt } ), type( ty ), member( mem ) {
-        assert( type );
-}
-
 // --- OffsetofExpr
 
@@ -277 +269 @@
 
 OffsetPackExpr::OffsetPackExpr( const CodeLocation & loc, const StructInstType * ty )
-: Expr( loc, new ArrayType{ 
-        new BasicType{ BasicType::LongUnsignedInt }, nullptr, FixedLen, DynamicDim } 
+: Expr( loc, new ArrayType{
+        new BasicType{ BasicType::LongUnsignedInt }, nullptr, FixedLen, DynamicDim }
 ), type( ty ) {
         assert( type );
@@ -285 +277 @@
 // --- LogicalExpr
 
-LogicalExpr::LogicalExpr( 
+LogicalExpr::LogicalExpr(
         const CodeLocation & loc, const Expr * a1, const Expr * a2, LogicalFlag ia )
 : Expr( loc, new BasicType{ BasicType::SignedInt } ), arg1( a1 ), arg2( a2 ), isAnd( ia ) {}

src/AST/Expr.hpp

@@ -28 +28 @@
 
 // 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);
+#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
 
 namespace ast {
@@ -133 +133 @@
 };
 
-/// The application of a function to a set of parameters. 
+/// The application of a function to a set of parameters.
 /// Post-resolver form of `UntypedExpr`
 class ApplicationExpr final : public Expr {
@@ -218 +218 @@
         GeneratedFlag isGenerated;
 
-        CastExpr( const CodeLocation & loc, const Expr * a, const Type * to, 
+        CastExpr( const CodeLocation & loc, const Expr * a, const Type * to,
                 GeneratedFlag g = GeneratedCast ) : Expr( loc, to ), arg( a ), isGenerated( g ) {}
         /// Cast-to-void
@@ -311 +311 @@
                 unsigned long long ival;
                 double dval;
-                
+
                 Val( unsigned long long i ) : ival( i ) {}
                 Val( double d ) : dval( d ) {}
@@ -318 +318 @@
         std::string rep;
 
-        ConstantExpr( 
+        ConstantExpr(
                 const CodeLocation & loc, const Type * ty, const std::string & r, unsigned long long v )
         : Expr( loc, ty ), val( v ), rep( r ) {}
         ConstantExpr( const CodeLocation & loc, const Type * ty, const std::string & r, double v )
         : Expr( loc, ty ), val( v ), rep( r ) {}
-        
+
         /// Gets the value of this constant as an integer
         long long int intValue() const;
@@ -464 +464 @@
         ptr<Expr> arg2;
 
-        CommaExpr( const CodeLocation & loc, const Expr * a1, const Expr * a2 ) 
+        CommaExpr( const CodeLocation & loc, const Expr * a1, const Expr * a2 )
         : Expr( loc ), arg1( a1 ), arg2( a2 ) {}
 
@@ -754 +754 @@
 };
 
-//=================================================================================================
-/// This disgusting and giant piece of boiler-plate is here to solve a cyclic dependency
-/// remove only if there is a better solution
-/// The problem is that ast::ptr< ... > uses increment/decrement which won't work well with
-/// forward declarations
-inline void increment( const class Expr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class Expr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class ApplicationExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class ApplicationExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class UntypedExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class UntypedExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class NameExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class NameExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class AddressExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class AddressExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class LabelAddressExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class LabelAddressExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class CastExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class CastExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class KeywordCastExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class KeywordCastExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class VirtualCastExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class VirtualCastExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class MemberExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class MemberExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class UntypedMemberExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class UntypedMemberExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class VariableExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class VariableExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class ConstantExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class ConstantExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class SizeofExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class SizeofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class AlignofExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class AlignofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class UntypedOffsetofExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class UntypedOffsetofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class OffsetofExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class OffsetofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class OffsetPackExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class OffsetPackExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class LogicalExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class LogicalExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class ConditionalExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class ConditionalExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class CommaExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class CommaExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class TypeExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class TypeExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class AsmExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class AsmExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class ImplicitCopyCtorExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class ImplicitCopyCtorExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class ConstructorExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class ConstructorExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class CompoundLiteralExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class CompoundLiteralExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class RangeExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class RangeExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class UntypedTupleExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class UntypedTupleExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class TupleExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class TupleExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class TupleIndexExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class TupleIndexExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class TupleAssignExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class TupleAssignExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class StmtExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class StmtExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class UniqueExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class UniqueExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class UntypedInitExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class UntypedInitExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class InitExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class InitExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class DeletedExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class DeletedExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class DefaultArgExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class DefaultArgExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class GenericExpr * node, Node::ref_type ref ) { node->increment(ref); }
-inline void decrement( const class GenericExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+
 }
 

src/AST/Fwd.hpp

@@ -135 +135 @@
 std::string toString( const Node * );
 
-//=================================================================================================
-/// This disgusting and giant piece of boiler-plate is here to solve a cyclic dependency
-/// remove only if there is a better solution
-/// The problem is that ast::ptr< ... > uses increment/decrement which won't work well with
-/// forward declarations
-inline void decrement( const class Node * node, Node::ref_type ref ) { node->decrement(ref); }
-inline void increment( const class Node * node, Node::ref_type ref ) { node->increment(ref); }
-inline void increment( const class ParseNode *, Node::ref_type );
-inline void decrement( const class ParseNode *, Node::ref_type );
-inline void increment( const class Decl *, Node::ref_type );
-inline void decrement( const class Decl *, Node::ref_type );
-inline void increment( const class DeclWithType *, Node::ref_type );
-inline void decrement( const class DeclWithType *, Node::ref_type );
-inline void increment( const class ObjectDecl *, Node::ref_type );
-inline void decrement( const class ObjectDecl *, Node::ref_type );
-inline void increment( const class FunctionDecl *, Node::ref_type );
-inline void decrement( const class FunctionDecl *, Node::ref_type );
-inline void increment( const class AggregateDecl *, Node::ref_type );
-inline void decrement( const class AggregateDecl *, Node::ref_type );
-inline void increment( const class StructDecl *, Node::ref_type );
-inline void decrement( const class StructDecl *, Node::ref_type );
-inline void increment( const class UnionDecl *, Node::ref_type );
-inline void decrement( const class UnionDecl *, Node::ref_type );
-inline void increment( const class EnumDecl *, Node::ref_type );
-inline void decrement( const class EnumDecl *, Node::ref_type );
-inline void increment( const class TraitDecl *, Node::ref_type );
-inline void decrement( const class TraitDecl *, Node::ref_type );
-inline void increment( const class NamedTypeDecl *, Node::ref_type );
-inline void decrement( const class NamedTypeDecl *, Node::ref_type );
-inline void increment( const class TypeDecl *, Node::ref_type );
-inline void decrement( const class TypeDecl *, Node::ref_type );
-inline void increment( const class TypedefDecl *, Node::ref_type );
-inline void decrement( const class TypedefDecl *, Node::ref_type );
-inline void increment( const class AsmDecl *, Node::ref_type );
-inline void decrement( const class AsmDecl *, Node::ref_type );
-inline void increment( const class StaticAssertDecl *, Node::ref_type );
-inline void decrement( const class StaticAssertDecl *, Node::ref_type );
-inline void increment( const class Stmt *, Node::ref_type );
-inline void decrement( const class Stmt *, Node::ref_type );
-inline void increment( const class CompoundStmt *, Node::ref_type );
-inline void decrement( const class CompoundStmt *, Node::ref_type );
-inline void increment( const class ExprStmt *, Node::ref_type );
-inline void decrement( const class ExprStmt *, Node::ref_type );
-inline void increment( const class AsmStmt *, Node::ref_type );
-inline void decrement( const class AsmStmt *, Node::ref_type );
-inline void increment( const class DirectiveStmt *, Node::ref_type );
-inline void decrement( const class DirectiveStmt *, Node::ref_type );
-inline void increment( const class IfStmt *, Node::ref_type );
-inline void decrement( const class IfStmt *, Node::ref_type );
-inline void increment( const class WhileStmt *, Node::ref_type );
-inline void decrement( const class WhileStmt *, Node::ref_type );
-inline void increment( const class ForStmt *, Node::ref_type );
-inline void decrement( const class ForStmt *, Node::ref_type );
-inline void increment( const class SwitchStmt *, Node::ref_type );
-inline void decrement( const class SwitchStmt *, Node::ref_type );
-inline void increment( const class CaseStmt *, Node::ref_type );
-inline void decrement( const class CaseStmt *, Node::ref_type );
-inline void increment( const class BranchStmt *, Node::ref_type );
-inline void decrement( const class BranchStmt *, Node::ref_type );
-inline void increment( const class ReturnStmt *, Node::ref_type );
-inline void decrement( const class ReturnStmt *, Node::ref_type );
-inline void increment( const class ThrowStmt *, Node::ref_type );
-inline void decrement( const class ThrowStmt *, Node::ref_type );
-inline void increment( const class TryStmt *, Node::ref_type );
-inline void decrement( const class TryStmt *, Node::ref_type );
-inline void increment( const class CatchStmt *, Node::ref_type );
-inline void decrement( const class CatchStmt *, Node::ref_type );
-inline void increment( const class FinallyStmt *, Node::ref_type );
-inline void decrement( const class FinallyStmt *, Node::ref_type );
-inline void increment( const class WaitForStmt *, Node::ref_type );
-inline void decrement( const class WaitForStmt *, Node::ref_type );
-inline void increment( const class WithStmt *, Node::ref_type );
-inline void decrement( const class WithStmt *, Node::ref_type );
-inline void increment( const class DeclStmt *, Node::ref_type );
-inline void decrement( const class DeclStmt *, Node::ref_type );
-inline void increment( const class NullStmt *, Node::ref_type );
-inline void decrement( const class NullStmt *, Node::ref_type );
-inline void increment( const class ImplicitCtorDtorStmt *, Node::ref_type );
-inline void decrement( const class ImplicitCtorDtorStmt *, Node::ref_type );
-inline void increment( const class Expr *, Node::ref_type );
-inline void decrement( const class Expr *, Node::ref_type );
-inline void increment( const class ApplicationExpr *, Node::ref_type );
-inline void decrement( const class ApplicationExpr *, Node::ref_type );
-inline void increment( const class UntypedExpr *, Node::ref_type );
-inline void decrement( const class UntypedExpr *, Node::ref_type );
-inline void increment( const class NameExpr *, Node::ref_type );
-inline void decrement( const class NameExpr *, Node::ref_type );
-inline void increment( const class AddressExpr *, Node::ref_type );
-inline void decrement( const class AddressExpr *, Node::ref_type );
-inline void increment( const class LabelAddressExpr *, Node::ref_type );
-inline void decrement( const class LabelAddressExpr *, Node::ref_type );
-inline void increment( const class CastExpr *, Node::ref_type );
-inline void decrement( const class CastExpr *, Node::ref_type );
-inline void increment( const class KeywordCastExpr *, Node::ref_type );
-inline void decrement( const class KeywordCastExpr *, Node::ref_type );
-inline void increment( const class VirtualCastExpr *, Node::ref_type );
-inline void decrement( const class VirtualCastExpr *, Node::ref_type );
-inline void increment( const class MemberExpr *, Node::ref_type );
-inline void decrement( const class MemberExpr *, Node::ref_type );
-inline void increment( const class UntypedMemberExpr *, Node::ref_type );
-inline void decrement( const class UntypedMemberExpr *, Node::ref_type );
-inline void increment( const class VariableExpr *, Node::ref_type );
-inline void decrement( const class VariableExpr *, Node::ref_type );
-inline void increment( const class ConstantExpr *, Node::ref_type );
-inline void decrement( const class ConstantExpr *, Node::ref_type );
-inline void increment( const class SizeofExpr *, Node::ref_type );
-inline void decrement( const class SizeofExpr *, Node::ref_type );
-inline void increment( const class AlignofExpr *, Node::ref_type );
-inline void decrement( const class AlignofExpr *, Node::ref_type );
-inline void increment( const class UntypedOffsetofExpr *, Node::ref_type );
-inline void decrement( const class UntypedOffsetofExpr *, Node::ref_type );
-inline void increment( const class OffsetofExpr *, Node::ref_type );
-inline void decrement( const class OffsetofExpr *, Node::ref_type );
-inline void increment( const class OffsetPackExpr *, Node::ref_type );
-inline void decrement( const class OffsetPackExpr *, Node::ref_type );
-inline void increment( const class LogicalExpr *, Node::ref_type );
-inline void decrement( const class LogicalExpr *, Node::ref_type );
-inline void increment( const class ConditionalExpr *, Node::ref_type );
-inline void decrement( const class ConditionalExpr *, Node::ref_type );
-inline void increment( const class CommaExpr *, Node::ref_type );
-inline void decrement( const class CommaExpr *, Node::ref_type );
-inline void increment( const class TypeExpr *, Node::ref_type );
-inline void decrement( const class TypeExpr *, Node::ref_type );
-inline void increment( const class AsmExpr *, Node::ref_type );
-inline void decrement( const class AsmExpr *, Node::ref_type );
-inline void increment( const class ImplicitCopyCtorExpr *, Node::ref_type );
-inline void decrement( const class ImplicitCopyCtorExpr *, Node::ref_type );
-inline void increment( const class ConstructorExpr *, Node::ref_type );
-inline void decrement( const class ConstructorExpr *, Node::ref_type );
-inline void increment( const class CompoundLiteralExpr *, Node::ref_type );
-inline void decrement( const class CompoundLiteralExpr *, Node::ref_type );
-inline void increment( const class RangeExpr *, Node::ref_type );
-inline void decrement( const class RangeExpr *, Node::ref_type );
-inline void increment( const class UntypedTupleExpr *, Node::ref_type );
-inline void decrement( const class UntypedTupleExpr *, Node::ref_type );
-inline void increment( const class TupleExpr *, Node::ref_type );
-inline void decrement( const class TupleExpr *, Node::ref_type );
-inline void increment( const class TupleIndexExpr *, Node::ref_type );
-inline void decrement( const class TupleIndexExpr *, Node::ref_type );
-inline void increment( const class TupleAssignExpr *, Node::ref_type );
-inline void decrement( const class TupleAssignExpr *, Node::ref_type );
-inline void increment( const class StmtExpr *, Node::ref_type );
-inline void decrement( const class StmtExpr *, Node::ref_type );
-inline void increment( const class UniqueExpr *, Node::ref_type );
-inline void decrement( const class UniqueExpr *, Node::ref_type );
-inline void increment( const class UntypedInitExpr *, Node::ref_type );
-inline void decrement( const class UntypedInitExpr *, Node::ref_type );
-inline void increment( const class InitExpr *, Node::ref_type );
-inline void decrement( const class InitExpr *, Node::ref_type );
-inline void increment( const class DeletedExpr *, Node::ref_type );
-inline void decrement( const class DeletedExpr *, Node::ref_type );
-inline void increment( const class DefaultArgExpr *, Node::ref_type );
-inline void decrement( const class DefaultArgExpr *, Node::ref_type );
-inline void increment( const class GenericExpr *, Node::ref_type );
-inline void decrement( const class GenericExpr *, Node::ref_type );
-inline void increment( const class Type *, Node::ref_type );
-inline void decrement( const class Type *, Node::ref_type );
-inline void increment( const class VoidType *, Node::ref_type );
-inline void decrement( const class VoidType *, Node::ref_type );
-inline void increment( const class BasicType *, Node::ref_type );
-inline void decrement( const class BasicType *, Node::ref_type );
-inline void increment( const class PointerType *, Node::ref_type );
-inline void decrement( const class PointerType *, Node::ref_type );
-inline void increment( const class ArrayType *, Node::ref_type );
-inline void decrement( const class ArrayType *, Node::ref_type );
-inline void increment( const class ReferenceType *, Node::ref_type );
-inline void decrement( const class ReferenceType *, Node::ref_type );
-inline void increment( const class QualifiedType *, Node::ref_type );
-inline void decrement( const class QualifiedType *, Node::ref_type );
-inline void increment( const class FunctionType *, Node::ref_type );
-inline void decrement( const class FunctionType *, Node::ref_type );
-inline void increment( const class ReferenceToType *, Node::ref_type );
-inline void decrement( const class ReferenceToType *, Node::ref_type );
-inline void increment( const class StructInstType *, Node::ref_type );
-inline void decrement( const class StructInstType *, Node::ref_type );
-inline void increment( const class UnionInstType *, Node::ref_type );
-inline void decrement( const class UnionInstType *, Node::ref_type );
-inline void increment( const class EnumInstType *, Node::ref_type );
-inline void decrement( const class EnumInstType *, Node::ref_type );
-inline void increment( const class TraitInstType *, Node::ref_type );
-inline void decrement( const class TraitInstType *, Node::ref_type );
-inline void increment( const class TypeInstType *, Node::ref_type );
-inline void decrement( const class TypeInstType *, Node::ref_type );
-inline void increment( const class TupleType *, Node::ref_type );
-inline void decrement( const class TupleType *, Node::ref_type );
-inline void increment( const class TypeofType *, Node::ref_type );
-inline void decrement( const class TypeofType *, Node::ref_type );
-inline void increment( const class VarArgsType *, Node::ref_type );
-inline void decrement( const class VarArgsType *, Node::ref_type );
-inline void increment( const class ZeroType *, Node::ref_type );
-inline void decrement( const class ZeroType *, Node::ref_type );
-inline void increment( const class OneType *, Node::ref_type );
-inline void decrement( const class OneType *, Node::ref_type );
-inline void increment( const class GlobalScopeType *, Node::ref_type );
-inline void decrement( const class GlobalScopeType *, Node::ref_type );
-inline void increment( const class Designation *, Node::ref_type );
-inline void decrement( const class Designation *, Node::ref_type );
-inline void increment( const class Init *, Node::ref_type );
-inline void decrement( const class Init *, Node::ref_type );
-inline void increment( const class SingleInit *, Node::ref_type );
-inline void decrement( const class SingleInit *, Node::ref_type );
-inline void increment( const class ListInit *, Node::ref_type );
-inline void decrement( const class ListInit *, Node::ref_type );
-inline void increment( const class ConstructorInit *, Node::ref_type );
-inline void decrement( const class ConstructorInit *, Node::ref_type );
-inline void increment( const class Constant *, Node::ref_type );
-inline void decrement( const class Constant *, Node::ref_type );
-inline void increment( const class Attribute *, Node::ref_type );
-inline void decrement( const class Attribute *, Node::ref_type );
-inline void increment( const class TypeSubstitution *, Node::ref_type );
-inline void decrement( const class TypeSubstitution *, Node::ref_type );
-
 typedef unsigned int UniqueId;
 

src/AST/Init.cpp

@@ -22 +22 @@
 namespace ast {
 
-ListInit::ListInit( const CodeLocation& loc, std::vector<ptr<Init>>&& is, 
-        std::vector<ptr<Designation>>&& ds, bool mc)
+ListInit::ListInit( const CodeLocation& loc, std::vector<ptr<Init>>&& is,
+        std::vector<ptr<Designation>>&& ds, ConstructFlag mc)
 : Init( loc, mc ), initializers( std::move(is) ), designations( std::move(ds) ) {
-        // handle common case where ListInit is created without designations by making an 
+        // handle common case where ListInit is created without designations by making an
         // equivalent-length empty list
         if ( designations.empty() ) {
@@ -32 +32 @@
                 }
         }
-        
+
         assertf( initializers.size() == designations.size(), "Created ListInit with mismatching "
                 "initializers (%zd) and designations (%zd)", initializers.size(), designations.size() );

src/AST/Init.hpp

@@ -24 +24 @@
 
 // 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);
+#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
 
 namespace ast {
@@ -58 +58 @@
         const Init * accept( Visitor& v ) const override = 0;
 private:
-        const Init * clone() const override = 0;
+        Init * clone() const override = 0;
         MUTATE_FRIEND
 };
@@ -122 +122 @@
 };
 
-
-//=================================================================================================
-/// This disgusting and giant piece of boiler-plate is here to solve a cyclic dependency
-/// remove only if there is a better solution
-/// The problem is that ast::ptr< ... > uses increment/decrement which won't work well with
-/// forward declarations
-inline void increment( const class Init * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class Init * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class SingleInit * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class SingleInit * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ListInit * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ListInit * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ConstructorInit * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ConstructorInit * node, Node::ref_type ref ) { node->decrement( ref ); }
 }
 

src/AST/LinkageSpec.cpp

@@ -43 +43 @@
 
         std::string name( Spec spec ) {
-                switch ( spec ) {
-                case Intrinsic:  return "intrinsic";
-                case C:          return "C";
-                case Cforall:    return "Cforall";
-                case AutoGen:    return "autogenerated cfa";
-                case Compiler:   return "compiler built-in";
-                case BuiltinCFA: return "cfa built-in";
-                case BuiltinC:   return "c built-in";
+                switch ( spec.val ) {
+                case Intrinsic.val:  return "intrinsic";
+                case C.val:          return "C";
+                case Cforall.val:    return "Cforall";
+                case AutoGen.val:    return "autogenerated cfa";
+                case Compiler.val:   return "compiler built-in";
+                case BuiltinCFA.val: return "cfa built-in";
+                case BuiltinC.val:   return "c built-in";
                 default:         return "<unnamed linkage spec>";
                 }

src/AST/Node.hpp

@@ -44 +44 @@
         };
 
-        inline void increment(ref_type ref) const {
+private:
+        /// Make a copy of this node; should be overridden in subclass with more precise return type
+        virtual Node * clone() const = 0;
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
+
+        mutable size_t strong_count = 0;
+        mutable size_t weak_count = 0;
+
+        void increment(ref_type ref) const {
                 switch (ref) {
                         case ref_type::strong: strong_count++; break;
@@ -51 +62 @@
         }
 
-        inline void decrement(ref_type ref) const {
+        void decrement(ast::Node::ref_type ref) const {
                 switch (ref) {
                         case ref_type::strong: strong_count--; break;
@@ -61 +72 @@
                 }
         }
-private:
-        /// Make a copy of this node; should be overridden in subclass with more precise return type
-        virtual const Node * clone() const = 0;
 
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
-
-        mutable size_t strong_count = 0;
-        mutable size_t weak_count = 0;
+        template< typename node_t, enum Node::ref_type ref_t >
+        friend class ptr_base;
 };
 
@@ -76 +80 @@
 // problems and be able to use auto return
 template<typename node_t>
-auto mutate( const node_t * node ) {
-        assertf(
-                node->strong_count >= 1,
-                "Error: attempting to mutate a node that appears to have been linked"
-        );
-        if (node->strong_count == 1) {
+node_t * mutate( const node_t * node ) {
+        if (node->strong_count <= 1) {
                 return const_cast<node_t *>(node);
         }
@@ -100 +100 @@
 public:
         ptr_base() : node(nullptr) {}
-        ptr_base( const node_t * n ) : node(n) { if( node ) increment(node, ref_t); }
-        ~ptr_base() { if( node ) decrement(node, ref_t); }
+        ptr_base( const node_t * n ) : node(n) { if( node ) _inc(node); }
+        ~ptr_base() { if( node ) _dec(node); }
 
         template< enum Node::ref_type o_ref_t >
         ptr_base( const ptr_base<node_t, o_ref_t> & o ) : node(o.node) {
-                if( node ) increment(node, ref_t);
+                if( node ) _inc(node);
         }
 
         template< enum Node::ref_type o_ref_t >
         ptr_base( ptr_base<node_t, o_ref_t> && o ) : node(o.node) {
-                if( node ) increment(node, ref_t);
+                if( node ) _inc(node);
         }
 
@@ -147 +147 @@
                 assign( n );
                 // get mutable version of `n`
-                auto r = mutate( node ); 
+                auto r = mutate( node );
                 // re-assign mutable version in case `mutate()` produced a new pointer
                 assign( r );
@@ -157 +157 @@
 private:
         void assign( const node_t * other ) {
-                if( other ) increment(other, ref_t);
-                if( node  ) decrement(node , ref_t);
+                if( other ) _inc(other);
+                if( node  ) _dec(node );
                 node = other;
         }
+
+        void _inc( const node_t * other );
+        void _dec( const node_t * other );
 
 protected:

src/AST/ParseNode.hpp

@@ -34 +34 @@
 
         ParseNode( const ParseNode& o ) = default;
+private:
+        ParseNode * clone() const override = 0;
+
+        /// Must be copied in ALL derived classes
+        template<typename node_t>
+        friend node_t * mutate(const node_t * node);
 };
 
-
-//=================================================================================================
-/// This disgusting and giant piece of boiler-plate is here to solve a cyclic dependency
-/// remove only if there is a better solution
-/// The problem is that ast::ptr< ... > uses increment/decrement which won't work well with
-/// forward declarations
-inline void increment( const class ParseNode * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ParseNode * node, Node::ref_type ref ) { node->decrement( ref ); }
 }
 

src/AST/Pass.hpp

@@ -133 +133 @@
         const ast::Expr *             visit( const ast::OffsetofExpr         * ) override final;
         const ast::Expr *             visit( const ast::OffsetPackExpr       * ) override final;
-        const ast::Expr *             visit( const ast::AttrExpr             * ) override final;
         const ast::Expr *             visit( const ast::LogicalExpr          * ) override final;
         const ast::Expr *             visit( const ast::ConditionalExpr      * ) override final;

src/AST/Pass.impl.hpp

@@ -19 +19 @@
 #include <type_traits>
 #include <unordered_map>
+
+#include "AST/TypeSubstitution.hpp"
 
 #define VISIT_START( node ) \
@@ -462 +464 @@
         VISIT({
                 guard_indexer guard { * this };
-                maybe_accept( node, &StructDecl::parameters );
-                maybe_accept( node, &StructDecl::members    );
+                maybe_accept( node, &StructDecl::params  );
+                maybe_accept( node, &StructDecl::members );
         })
 
@@ -483 +485 @@
         VISIT({
                 guard_indexer guard { * this };
-                maybe_accept( node, &UnionDecl::parameters );
-                maybe_accept( node, &UnionDecl::members    );
+                maybe_accept( node, &UnionDecl::params  );
+                maybe_accept( node, &UnionDecl::members );
         })
 
@@ -502 +504 @@
         VISIT(
                 // unlike structs, traits, and unions, enums inject their members into the global scope
-                maybe_accept( node, &EnumDecl::parameters );
-                maybe_accept( node, &EnumDecl::members    );
+                maybe_accept( node, &EnumDecl::params  );
+                maybe_accept( node, &EnumDecl::members );
         )
 
@@ -517 +519 @@
         VISIT({
                 guard_indexer guard { *this };
-                maybe_accept( node, &TraitDecl::parameters );
-                maybe_accept( node, &TraitDecl::members    );
+                maybe_accept( node, &TraitDecl::params  );
+                maybe_accept( node, &TraitDecl::members );
         })
 
@@ -534 +536 @@
         VISIT({
                 guard_indexer guard { *this };
-                maybe_accept( node, &TypeDecl::parameters );
-                maybe_accept( node, &TypeDecl::base       );
+                maybe_accept( node, &TypeDecl::params );
+                maybe_accept( node, &TypeDecl::base   );
         })
 
@@ -563 +565 @@
         VISIT({
                 guard_indexer guard { *this };
-                maybe_accept( node, &TypedefDecl::parameters );
-                maybe_accept( node, &TypedefDecl::base       );
+                maybe_accept( node, &TypedefDecl::params );
+                maybe_accept( node, &TypedefDecl::base   );
         })
 
@@ -688 +690 @@
                 maybe_accept( node, &WhileStmt::body  );
         })
+
+        VISIT_END( Stmt, node );
+}
+
+//--------------------------------------------------------------------------
+// ForStmt
+template< typename pass_t >
+const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ForStmt * node ) {
+        VISIT_START( node );
+
+        VISIT({
+                // for statements introduce a level of scope (for the initialization)
+                guard_indexer guard { *this };
+                maybe_accept( node, &ForStmt::inits );
+                maybe_accept( node, &ForStmt::cond  );
+                maybe_accept( node, &ForStmt::inc   );
+                maybe_accept( node, &ForStmt::body  );
+        })
+
+        VISIT_END( Stmt, node );
+}
+
+//--------------------------------------------------------------------------
+// SwitchStmt
+template< typename pass_t >
+const ast::Stmt * ast::Pass< pass_t >::visit( const ast::SwitchStmt * node ) {
+        VISIT_START( node );
+
+        VISIT(
+                maybe_accept( node, &SwitchStmt::cond  );
+                maybe_accept( node, &SwitchStmt::stmts );
+        )
+
+        VISIT_END( Stmt, node );
+}
+
+//--------------------------------------------------------------------------
+// CaseStmt
+template< typename pass_t >
+const ast::Stmt * ast::Pass< pass_t >::visit( const ast::CaseStmt * node ) {
+        VISIT_START( node );
+
+        VISIT(
+                maybe_accept( node, &CaseStmt::cond  );
+                maybe_accept( node, &CaseStmt::stmts );
+        )
+
+        VISIT_END( Stmt, node );
+}
+
+//--------------------------------------------------------------------------
+// BranchStmt
+template< typename pass_t >
+const ast::Stmt * ast::Pass< pass_t >::visit( const ast::BranchStmt * node ) {
+        VISIT_START( node );
+        VISIT_END( Stmt, node );
+}
+
+//--------------------------------------------------------------------------
+// ReturnStmt
+template< typename pass_t >
+const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ReturnStmt * node ) {
+        VISIT_START( node );
+
+        VISIT(
+                maybe_accept( node, &ReturnStmt::expr );
+        )
+
+        VISIT_END( Stmt, node );
+}
+
+//--------------------------------------------------------------------------
+// ThrowStmt
+template< typename pass_t >
+const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ThrowStmt * node ) {
+        VISIT_START( node );
+
+        VISIT(
+                maybe_accept( node, &ThrowStmt::expr   );
+                maybe_accept( node, &ThrowStmt::target );
+        )
+
+        VISIT_END( Stmt, node );
+}
+
+//--------------------------------------------------------------------------
+// TryStmt
+template< typename pass_t >
+const ast::Stmt * ast::Pass< pass_t >::visit( const ast::TryStmt * node ) {
+        VISIT_START( node );
+
+        VISIT(
+                maybe_accept( node, &TryStmt::body     );
+                maybe_accept( node, &TryStmt::handlers );
+                maybe_accept( node, &TryStmt::finally  );
+        )
 
         VISIT_END( Stmt, node );

src/AST/Pass.proto.hpp

@@ -247 +247 @@
                 static inline auto addStructFwd( pass_t & pass, int, const ast::StructDecl * decl ) -> decltype( pass.indexer.addStruct( decl ), void() ) {
                         ast::StructDecl * fwd = new ast::StructDecl( decl->location, decl->name );
-                        fwd->parameters = decl->parameters;
+                        fwd->params = decl->params;
                         pass.indexer.addStruct( fwd );
                 }
@@ -257 +257 @@
                 static inline auto addUnionFwd( pass_t & pass, int, const ast::UnionDecl * decl ) -> decltype( pass.indexer.addUnion( decl ), void() ) {
                         UnionDecl * fwd = new UnionDecl( decl->location, decl->name );
-                        fwd->parameters = decl->parameters;
+                        fwd->params = decl->params;
                         pass.indexer.addUnion( fwd );
                 }

src/AST/Stmt.cpp

@@ -26 +26 @@
 
 // --- BranchStmt
-BranchStmt( const CodeLocation& loc, Kind kind, Label target, std::vector<Label>&& labels )
+BranchStmt::BranchStmt( const CodeLocation& loc, Kind kind, Label target, std::vector<Label>&& labels )
 : Stmt(loc, std::move(labels)), originalTarget(target), target(target), kind(kind) {
         // Make sure a syntax error hasn't slipped through.
@@ -34 +34 @@
 const char * BranchStmt::kindNames[] = {
     "Goto", "Break", "Continue", "FallThrough", "FallThroughDefault"
-}
+};
 
 }

src/AST/Stmt.hpp

@@ -10 +10 @@
 // Created On       : Wed May  8 13:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed May 15 16:01:00 2019
-// Update Count     : 2
+// Last Modified On : Wed May 16 12:20:00 2019
+// Update Count     : 3
 //
 
@@ -27 +27 @@
 
 // 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);
+#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
 
 namespace ast {
@@ -86 +86 @@
         ptr<Expr> expr;
 
-        ExprStmt( const CodeLocation & loc, const Expr * e ) : Stmt(loc), expr(e) {}
+        ExprStmt( const CodeLocation& loc, const Expr* e, std::vector<Label>&& labels = {} )
+        : Stmt(loc, std::move(labels)), expr(e) {}
 
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -404 +405 @@
 };
 
-//=================================================================================================
-/// This disgusting and giant piece of boiler-plate is here to solve a cyclic dependency
-/// remove only if there is a better solution
-/// The problem is that ast::ptr< ... > uses increment/decrement which won't work well with
-/// forward declarations
-inline void increment( const class Stmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class Stmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class CompoundStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class CompoundStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ExprStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ExprStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class AsmStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class AsmStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class DirectiveStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class DirectiveStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class IfStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class IfStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class WhileStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class WhileStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ForStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ForStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class SwitchStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class SwitchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class CaseStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class CaseStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class BranchStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class BranchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ReturnStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ReturnStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ThrowStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ThrowStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class TryStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class TryStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class CatchStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class CatchStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class FinallyStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class FinallyStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class WaitForStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class WaitForStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class WithStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class WithStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class DeclStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class DeclStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class NullStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class NullStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ImplicitCtorDtorStmt * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ImplicitCtorDtorStmt * node, Node::ref_type ref ) { node->decrement( ref ); }
-
 }
 

src/AST/Type.cpp

@@ -42 +42 @@
         const Type * t;
         const ReferenceType * r;
-        for ( t = this; (r = dynamic_cast<const ReferenceType *>() ); t = r->base );
+        for ( t = this; (r = dynamic_cast<const ReferenceType *>(t) ); t = r->base );
         return t;
 }
@@ -103 +103 @@
 
 bool FunctionType::isTtype() const {
-        return containsTtype( returnVals ) || containsTtype( parameters );
+        return containsTtype( returns ) || containsTtype( params );
 }
 
@@ -109 +109 @@
 std::vector<readonly<Decl>> ReferenceToType::lookup( const std::string& name ) const {
         assertf( aggr(), "Must have aggregate to perform lookup" );
-        
+
         std::vector<readonly<Decl>> found;
         for ( const Decl * decl : aggr()->members ) {
@@ -119 +119 @@
 // --- StructInstType
 
-StructInstType::StructInstType( const StructDecl * b, CV::Qualifiers q = {}, 
-        std::vector<ptr<Attribute>>&& as = {} )
+StructInstType::StructInstType( const StructDecl * b, CV::Qualifiers q,
+        std::vector<ptr<Attribute>>&& as )
 : ReferenceToType( b->name, q, std::move(as) ), base( b ) {}
 
@@ -127 +127 @@
 // --- UnionInstType
 
-UnionInstType::UnionInstType( const UnionDecl * b, CV::Qualifiers q = {}, 
-        std::vector<ptr<Attribute>>&& as = {} )
+UnionInstType::UnionInstType( const UnionDecl * b, CV::Qualifiers q,
+        std::vector<ptr<Attribute>>&& as )
 : ReferenceToType( b->name, q, std::move(as) ), base( b ) {}
 
@@ -135 +135 @@
 // --- EnumInstType
 
-EnumInstType::EnumInstType( const EnumDecl * b, CV::Qualifiers q = {}, 
-        std::vector<ptr<Attribute>>&& as = {} )
+EnumInstType::EnumInstType( const EnumDecl * b, CV::Qualifiers q,
+        std::vector<ptr<Attribute>>&& as )
 : ReferenceToType( b->name, q, std::move(as) ), base( b ) {}
 
@@ -152 +152 @@
 // --- TupleType
 
-TupleType::TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q = {} )
+TupleType::TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q )
 : Type( q ), types( std::move(ts) ), members() {
-        // This constructor is awkward. `TupleType` needs to contain objects so that members can be 
-        // named, but members without initializer nodes end up getting constructors, which breaks 
-        // things. This happens because the object decls have to be visited so that their types are 
-        // kept in sync with the types listed here. Ultimately, the types listed here should perhaps 
-        // be eliminated and replaced with a list-view over members. The temporary solution is to 
-        // make a `ListInit` with `maybeConstructed = false`, so when the object is visited it is not 
+        // This constructor is awkward. `TupleType` needs to contain objects so that members can be
+        // named, but members without initializer nodes end up getting constructors, which breaks
+        // things. This happens because the object decls have to be visited so that their types are
+        // kept in sync with the types listed here. Ultimately, the types listed here should perhaps
+        // be eliminated and replaced with a list-view over members. The temporary solution is to
+        // make a `ListInit` with `maybeConstructed = false`, so when the object is visited it is not
         // constructed. Potential better solutions include:
-        //   a) Separate `TupleType` from its declarations, into `TupleDecl` and `Tuple{Inst?}Type`, 
+        //   a) Separate `TupleType` from its declarations, into `TupleDecl` and `Tuple{Inst?}Type`,
         //      similar to the aggregate types.
-        //   b) Separate initializer nodes better, e.g. add a `MaybeConstructed` node that is replaced 
+        //   b) Separate initializer nodes better, e.g. add a `MaybeConstructed` node that is replaced
         //      by `genInit`, rather than the current boolean flag.
         members.reserve( types.size() );
         for ( const Type * ty : types ) {
                 members.emplace_back( new ObjectDecl{
-                        CodeLocation{}, "", ty, new ListInit( CodeLocation{}, {}, {}, MaybeConstruct ), 
+                        CodeLocation{}, "", ty, new ListInit( CodeLocation{}, {}, {}, MaybeConstruct ),
                         Storage::Classes{}, Linkage::Cforall } );
         }

src/AST/Type.hpp

@@ -30 +30 @@
 
 // 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);
+#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
 
 namespace ast {
@@ -37 +37 @@
 public:
         CV::Qualifiers qualifiers;
-        
+
         Type( CV::Qualifiers q = {} ) : qualifiers(q) {}
 
@@ -80 +80 @@
 public:
         VoidType( CV::Qualifiers q = {} ) : Type( q ) {}
-        
+
         unsigned size() const override { return 0; }
         bool isVoid() const override { return true; }
@@ -171 +171 @@
 
         PointerType( const Type * b, CV::Qualifiers q = {} ) : Type(q), base(b), dimension() {}
-        PointerType( const Type * b, const Expr * d, LengthFlag vl, DimensionFlag s, 
+        PointerType( const Type * b, const Expr * d, LengthFlag vl, DimensionFlag s,
                 CV::Qualifiers q = {} ) : Type(q), base(b), dimension(d), isVarLen(vl), isStatic(s) {}
 
@@ -193 +193 @@
         DimensionFlag isStatic;
 
-        ArrayType( const Type * b, const Expr * d, LengthFlag vl, DimensionFlag s, 
+        ArrayType( const Type * b, const Expr * d, LengthFlag vl, DimensionFlag s,
                 CV::Qualifiers q = {} ) : Type(q), base(b), dimension(d), isVarLen(vl), isStatic(s) {}
 
@@ -233 +233 @@
         ptr<Type> child;
 
-        QualifiedType( const Type * p, const Type * c, CV::Qualifiers q = {} ) 
+        QualifiedType( const Type * p, const Type * c, CV::Qualifiers q = {} )
         : Type(q), parent(p), child(c) {}
 
@@ -249 +249 @@
         ForallList forall;
 
-        ParameterizedType( ForallList&& fs = {}, CV::Qualifiers q = {} ) 
+        ParameterizedType( ForallList&& fs = {}, CV::Qualifiers q = {} )
         : Type(q), forall(std::move(fs)) {}
         ParameterizedType( CV::Qualifiers q ) : Type(q), forall() {}
@@ -267 +267 @@
         std::vector<ptr<DeclWithType>> params;
 
-        /// Does the function accept a variable number of arguments following the arguments specified 
+        /// Does the function accept a variable number of arguments following the arguments specified
         /// in the parameters list.
         /// This could be because of
@@ -296 +296 @@
         bool hoistType = false;
 
-        ReferenceToType( const std::string& n, CV::Qualifiers q = {}, 
+        ReferenceToType( const std::string& n, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ParameterizedType(q), params(), attributes(std::move(as)), name(n) {}
@@ -319 +319 @@
         readonly<StructDecl> base;
 
-        StructInstType( const std::string& n, CV::Qualifiers q = {}, 
+        StructInstType( const std::string& n, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base() {}
-        StructInstType( const StructDecl * b, CV::Qualifiers q = {}, 
+        StructInstType( const StructDecl * b, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} );
-        
+
         bool isComplete() const override;
 
@@ -342 +342 @@
         readonly<UnionDecl> base;
 
-        UnionInstType( const std::string& n, CV::Qualifiers q = {}, 
+        UnionInstType( const std::string& n, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base() {}
-        UnionInstType( const UnionDecl * b, CV::Qualifiers q = {}, 
+        UnionInstType( const UnionDecl * b, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} );
-        
+
         bool isComplete() const override;
 
@@ -365 +365 @@
         readonly<EnumDecl> base;
 
-        EnumInstType( const std::string& n, CV::Qualifiers q = {}, 
+        EnumInstType( const std::string& n, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base() {}
-        EnumInstType( const EnumDecl * b, CV::Qualifiers q = {}, 
+        EnumInstType( const EnumDecl * b, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} );
-        
+
         bool isComplete() const override;
 
@@ -388 +388 @@
         readonly<TraitDecl> base;
 
-        TraitInstType( const std::string& n, CV::Qualifiers q = {}, 
+        TraitInstType( const std::string& n, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base() {}
-        TraitInstType( const TraitDecl * b, CV::Qualifiers q = {}, 
+        TraitInstType( const TraitDecl * b, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} );
-        
+
         // not meaningful for TraitInstType
         bool isComplete() const override { assert(false); }
@@ -413 +413 @@
         TypeVar::Kind kind;
 
-        TypeInstType( const std::string& n, const TypeDecl * b, CV::Qualifiers q = {}, 
+        TypeInstType( const std::string& n, const TypeDecl * b, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base( b ), kind( b->kind ) {}
-        TypeInstType( const std::string& n, TypeVar::Kind k, CV::Qualifiers q = {}, 
+        TypeInstType( const std::string& n, TypeVar::Kind k, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base(), kind( k ) {}
@@ -448 +448 @@
         iterator begin() const { return types.begin(); }
         iterator end() const { return types.end(); }
-        
+
         unsigned size() const override { return types.size(); }
 
         const Type * getComponent( unsigned i ) override {
-                assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", 
+                assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d",
                         i, size() );
                 return *(begin()+i);
@@ -469 +469 @@
         enum Kind { Typeof, Basetypeof } kind;
 
-        TypeofType( const Expr * e, Kind k = Typeof, CV::Qualifiers q = {} ) 
+        TypeofType( const Expr * e, Kind k = Typeof, CV::Qualifiers q = {} )
         : Type(q), expr(e), kind(k) {}
 
@@ -482 +482 @@
 public:
         VarArgsType( CV::Qualifiers q = {} ) : Type( q ) {}
-        
+
         const Type * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
@@ -493 +493 @@
 public:
         ZeroType( CV::Qualifiers q = {} ) : Type( q ) {}
-        
+
         const Type * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
@@ -521 +521 @@
         MUTATE_FRIEND
 };
-
-//=================================================================================================
-/// This disgusting and giant piece of boiler-plate is here to solve a cyclic dependency
-/// remove only if there is a better solution.
-/// The problem is that ast::ptr< ... > uses increment/decrement which won't work well with
-/// forward declarations
-inline void increment( const class Type * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class Type * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class VoidType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class VoidType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class BasicType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class BasicType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class PointerType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class PointerType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ArrayType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ArrayType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ReferenceType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ReferenceType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class QualifiedType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class QualifiedType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class FunctionType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class FunctionType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ReferenceToType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ReferenceToType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class StructInstType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class StructInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class UnionInstType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class UnionInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class EnumInstType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class EnumInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class TraitInstType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class TraitInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class TypeInstType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class TypeInstType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class TupleType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class TupleType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class TypeofType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class TypeofType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class VarArgsType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class VarArgsType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class ZeroType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class ZeroType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class OneType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class OneType * node, Node::ref_type ref ) { node->decrement( ref ); }
-inline void increment( const class GlobalScopeType * node, Node::ref_type ref ) { node->increment( ref ); }
-inline void decrement( const class GlobalScopeType * node, Node::ref_type ref ) { node->decrement( ref ); }
 
 }

src/AST/porting.md

@@ -48 +48 @@
       /// Must be copied in ALL derived classes
       template<typename node_t>
-      friend auto mutate(const node_t * node);
+      friend node_t * mutate(const node_t * node);
 
 All leaves of the `Node` inheritance tree are now declared `final`

src/Common/utility.h

@@ -463 +463 @@
 std::pair<long long int, bool> eval(Expression * expr);
 
-// -----------------------------------------------------------------------------
-/// Reorders the input range in-place so that the minimal-value elements according to the 
-/// comparator are in front; 
+namespace ast {
+        class Expr;
+}
+
+std::pair<long long int, bool> eval(const ast::Expr * expr);
+
+// -----------------------------------------------------------------------------
+/// Reorders the input range in-place so that the minimal-value elements according to the
+/// comparator are in front;
 /// returns the iterator after the last minimal-value element.
 template<typename Iter, typename Compare>
 Iter sort_mins( Iter begin, Iter end, Compare& lt ) {
         if ( begin == end ) return end;
-        
+
         Iter min_pos = begin;
         for ( Iter i = begin + 1; i != end; ++i ) {

src/Parser/ExpressionNode.cc

@@ -62 +62 @@
 static inline bool checkB( char c ) { return c == 'b' || c == 'B'; }
 static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
-static inline bool checkN( char c ) { return c == 'n' || c == 'N'; }
+// static inline bool checkN( char c ) { return c == 'n' || c == 'N'; }
 
 void lnthSuffix( string & str, int & type, int & ltype ) {
@@ -217 +217 @@
                 } else {                                                                                // explicit length, (length_type)constant
                         ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][ltype], false ), false );
-                        if ( ltype == 5 ) {                                                     // pointer, intptr( (uintptr_t)constant ) 
-                                ret = build_func( new ExpressionNode( build_varref( new string( "intptr" ) ) ), new ExpressionNode( ret ) );                                                              
+                        if ( ltype == 5 ) {                                                     // pointer, intptr( (uintptr_t)constant )
+                                ret = build_func( new ExpressionNode( build_varref( new string( "intptr" ) ) ), new ExpressionNode( ret ) );
                         } // if
                 } // if

src/SynTree/SynTree.h

@@ -34 +34 @@
 class NamedTypeDecl;
 class TypeDecl;
-class FtypeDecl;
-class DtypeDecl;
 class TypedefDecl;
 class AsmDecl;