Changeset 204358b

Timestamp:

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

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

b336af9

Parents:

10248ae0 (diff), f3cc5b6 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• AST/CVQualifiers.hpp (modified) (2 diffs)
• AST/Convert.cpp (modified) (1 diff)
• AST/Decl.hpp (modified) (18 diffs)
• AST/Expr.cpp (added)
• AST/Expr.hpp (modified) (6 diffs)
• AST/Fwd.hpp (modified) (2 diffs)
• AST/Init.hpp (modified) (7 diffs)
• AST/Node.hpp (modified) (3 diffs)
• AST/Stmt.hpp (modified) (25 diffs)
• AST/Type.hpp (modified) (26 diffs)
• AST/Visitor.hpp (modified) (1 diff)
• AST/porting.md (modified) (7 diffs)
• ResolvExpr/Unify.cc (modified) (3 diffs)
• ResolvExpr/typeops.h (modified) (2 diffs)

src/AST/CVQualifiers.hpp

@@ -59 +59 @@
         // ordering is a subtype relationship over qualifiers, e.g. `int` => `const int` is free
 
-        bool operator== ( Qualifiers a, Qualifiers b ) {
+        inline bool operator== ( Qualifiers a, Qualifiers b ) {
                 return (a.val & EquivQualifiers) == (b.val & EquivQualifiers);
         }
-        bool operator!= ( Qualifiers a, Qualifiers b ) {
+        inline bool operator!= ( Qualifiers a, Qualifiers b ) {
                 return !(a == b);
         }
-        bool operator<= ( Qualifiers a, Qualifiers b ) {
+        inline bool operator<= ( Qualifiers a, Qualifiers b ) {
                 return a.is_const    <= b.is_const    // non-const converts to const for free
                         && a.is_volatile <= b.is_volatile // non-volatile converts to volatile for free
@@ -71 +71 @@
                         && a.is_atomic   == b.is_atomic;  // atomicity must be preserved in free conversion
         }
-        bool operator<  ( Qualifiers a, Qualifiers b ) { return a != b && a <= b; }
-        bool operator>= ( Qualifiers a, Qualifiers b ) { return b <= a; }
-        bool operator>  ( Qualifiers a, Qualifiers b ) { return b < a; }
+        inline bool operator<  ( Qualifiers a, Qualifiers b ) { return a != b && a <= b; }
+        inline bool operator>= ( Qualifiers a, Qualifiers b ) { return b <= a; }
+        inline bool operator>  ( Qualifiers a, Qualifiers b ) { return b < a; }
 
 }

src/AST/Convert.cpp

@@ -413 +413 @@
         }
 
-        virtual void visit( AttrExpr * ) override final {
-
-        }
-
         virtual void visit( LogicalExpr * ) override final {
 

src/AST/Decl.hpp

@@ -30 +30 @@
 #include "Parser/ParseNode.h"  // for DeclarationNode::Aggregate
 
+// Must be included in *all* AST classes; should be #undef'd at the end of the file
+#define MUTATE_FRIEND template<typename node_t> friend auto mutate(const node_t * node);
+
 namespace ast {
-
-class Attribute;
-class Expr;
-class Init;
-class TypeDecl;
 
 /// Base declaration class
@@ -60 +58 @@
 private:
         Decl * clone() const override = 0;
+        MUTATE_FRIEND
 };
 
@@ -92 +91 @@
 private:
         DeclWithType * clone() const override = 0;
+        MUTATE_FRIEND
 };
 
@@ -113 +113 @@
 private:
         ObjectDecl * clone() const override { return new ObjectDecl{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
@@ -140 +137 @@
 private:
         FunctionDecl * clone() const override { return new FunctionDecl( *this ); }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
@@ -150 +144 @@
 public:
         ptr<Type> base;
-        std::vector<ptr<TypeDecl>> parameters;
+        std::vector<ptr<TypeDecl>> params;
         std::vector<ptr<DeclWithType>> assertions;
 
         NamedTypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage,
                 Type* b, Linkage::Spec spec = Linkage::Cforall )
-        : Decl( loc, name, storage, spec ), base( b ), parameters(), assertions() {}
+        : Decl( loc, name, storage, spec ), base( b ), params(), assertions() {}
 
         /// Produces a name for the kind of alias
@@ -162 +156 @@
 private:
         NamedTypeDecl* clone() const override = 0;
+        MUTATE_FRIEND
 };
 
@@ -203 +198 @@
 private:
         TypeDecl * clone() const override { return new TypeDecl{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
@@ -221 +213 @@
 private:
         TypedefDecl * clone() const override { return new TypedefDecl{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
@@ -231 +220 @@
 public:
         std::vector<ptr<Decl>> members;
-        std::vector<ptr<TypeDecl>> parameters;
+        std::vector<ptr<TypeDecl>> params;
         std::vector<ptr<Attribute>> attributes;
         bool body = false;
@@ -238 +227 @@
         AggregateDecl( const CodeLocation& loc, const std::string& name,
                 std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall )
-        : Decl( loc, name, Storage::Classes{}, linkage ), members(), parameters(),
+        : Decl( loc, name, Storage::Classes{}, linkage ), members(), params(),
           attributes( std::move(attrs) ) {}
 
         AggregateDecl* set_body( bool b ) { body = b; return this; }
+
+private:
+        AggregateDecl * clone() const override = 0;
+        MUTATE_FRIEND
 
 protected:
@@ -265 +258 @@
 private:
         StructDecl * clone() const override { return new StructDecl{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        MUTATE_FRIEND
 
         std::string typeString() const override { return "struct"; }
@@ -283 +273 @@
 private:
         UnionDecl * clone() const override { return new UnionDecl{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        MUTATE_FRIEND
 
         std::string typeString() const override { return "union"; }
@@ -304 +291 @@
 private:
         EnumDecl * clone() const override { return new EnumDecl{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        MUTATE_FRIEND
 
         std::string typeString() const override { return "enum"; }
@@ -325 +309 @@
 private:
         TraitDecl * clone() const override { return new TraitDecl{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        MUTATE_FRIEND
 
         std::string typeString() const override { return "trait"; }
@@ -343 +324 @@
 private:
         AsmDecl *clone() const override { return new AsmDecl( *this ); }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
@@ -360 +338 @@
 private:
         StaticAssertDecl * clone() const override { return new StaticAssertDecl( *this ); }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
@@ -402 +377 @@
 }
 
+#undef MUTATE_FRIEND
+
 // Local Variables: //
 // tab-width: 4 //

src/AST/Expr.hpp

@@ -18 +18 @@
 #include <cassert>
 #include <map>
+#include <string>
 #include <utility>        // for move
 #include <vector>
 
 #include "Fwd.hpp"        // for UniqueId
+#include "Label.hpp"
 #include "ParseNode.hpp"
 #include "Visitor.hpp"
+
+// Must be included in *all* AST classes; should be #undef'd at the end of the file
+#define MUTATE_FRIEND template<typename node_t> friend auto mutate(const node_t * node);
 
 namespace ast {
@@ -117 +122 @@
         bool extension = false;
 
-        Expr(const CodeLocation & loc ) : ParseNode( loc ), result(), env(), inferred() {}
+        Expr( const CodeLocation & loc, const Type * res = nullptr )
+        : ParseNode( loc ), result( res ), env(), inferred() {}
 
         Expr * set_extension( bool ex ) { extension = ex; return this; }
@@ -124 +130 @@
 private:
         Expr * clone() const override = 0;
+        MUTATE_FRIEND
+};
+
+/// The application of a function to a set of parameters. 
+/// Post-resolver form of `UntypedExpr`
+class ApplicationExpr final : public Expr {
+public:
+        ptr<Expr> func;
+        std::vector<ptr<Expr>> args;
+
+        ApplicationExpr( const CodeLocation & loc, const Expr * f, std::vector<ptr<Expr>> && as = {} );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        ApplicationExpr * clone() const override { return new ApplicationExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// The application of a function to a set of parameters, pre-overload resolution.
+class UntypedExpr final : public Expr {
+public:
+        ptr<Expr> func;
+        std::vector<ptr<Expr>> args;
+
+        UntypedExpr( const CodeLocation & loc, const Expr * f, std::vector<ptr<Expr>> && as = {} )
+        : Expr( loc ), func( f ), args( std::move(as) ) {}
+
+        /// Creates a new dereference expression
+        static UntypedExpr * createDeref( const CodeLocation & loc, Expr * arg );
+        /// Creates a new assignment expression
+        static UntypedExpr * createAssign( const CodeLocation & loc, Expr * lhs, Expr * rhs );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        UntypedExpr * clone() const override { return new UntypedExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// A name whose name is as-yet undetermined.
+/// May also be used to avoid name mangling in codegen phase.
+class NameExpr final : public Expr {
+public:
+        std::string name;
+
+        NameExpr( const CodeLocation & loc, const std::string & n ) : Expr( loc ), name( n ) {}
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        NameExpr * clone() const override { return new NameExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// Address-of expression `&e`
+class AddressExpr final : public Expr {
+public:
+        ptr<Expr> arg;
+
+        AddressExpr( const CodeLocation & loc, const Expr * a );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        AddressExpr * clone() const override { return new AddressExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// GCC &&label
+/// https://gcc.gnu.org/onlinedocs/gcc-3.4.2/gcc/Labels-as-Values.html
+class LabelAddressExpr final : public Expr {
+public:
+        Label arg;
+
+        LabelAddressExpr( const CodeLocation & loc, Label && a );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        LabelAddressExpr * clone() const override { return new LabelAddressExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// Whether a cast existed in the program source or not
+enum GeneratedFlag { ExplicitCast, GeneratedCast };
+
+/// A type cast, e.g. `(int)e`
+class CastExpr final : public Expr {
+public:
+        ptr<Expr> arg;
+        GeneratedFlag isGenerated;
+
+        CastExpr( const CodeLocation & loc, const Expr * a, const Type * to, 
+                GeneratedFlag g = GeneratedCast ) : Expr( loc, to ), arg( a ), isGenerated( g ) {}
+        /// Cast-to-void
+        CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g = GeneratedCast );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        CastExpr * clone() const override { return new CastExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// A cast to "keyword types", e.g. `(thread &)t`
+class KeywordCastExpr final : public Expr {
+public:
+        ptr<Expr> arg;
+        enum Target { Coroutine, Thread, Monitor, NUMBER_OF_TARGETS } target;
+
+        KeywordCastExpr( const CodeLocation & loc, const Expr * a, Target t )
+        : Expr( loc ), arg( a ), target( t ) {}
+
+        /// Get a name for the target type
+        const std::string& targetString() const;
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        KeywordCastExpr * clone() const override { return new KeywordCastExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// A virtual dynamic cast, e.g. `(virtual exception)e`
+class VirtualCastExpr final : public Expr {
+public:
+        ptr<Expr> arg;
+
+        VirtualCastExpr( const CodeLocation & loc, const Expr * a, const Type * to )
+        : Expr( loc, to ), arg( a ) {}
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        VirtualCastExpr * clone() const override { return new VirtualCastExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// A member selection operation before expression resolution, e.g. `q.p`
+class UntypedMemberExpr final : public Expr {
+public:
+        ptr<Expr> member;
+        ptr<Expr> aggregate;
+
+        UntypedMemberExpr( const CodeLocation & loc, const Expr * mem, const Expr * agg )
+        : Expr( loc ), member( mem ), aggregate( agg ) { assert( aggregate ); }
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        UntypedMemberExpr * clone() const override { return new UntypedMemberExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// A member selection operation after expression resolution, e.g. `q.p`
+class MemberExpr final : public Expr {
+public:
+        readonly<DeclWithType> member;
+        ptr<Expr> aggregate;
+
+        MemberExpr( const CodeLocation & loc, const DeclWithType * mem, const Expr * agg );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        MemberExpr * clone() const override { return new MemberExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// A reference to a named variable.
+class VariableExpr final : public Expr {
+public:
+        readonly<DeclWithType> var;
+
+        VariableExpr( const CodeLocation & loc, const DeclWithType * v );
+
+        /// generates a function pointer for a given function
+        static VariableExpr * functionPointer( const CodeLocation & loc, const FunctionDecl * decl );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        VariableExpr * clone() const override { return new VariableExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// A compile-time constant
+class ConstantExpr final : public Expr {
+        union Val {
+                unsigned long long ival;
+                double dval;
+                
+                Val( unsigned long long i ) : ival( i ) {}
+                Val( double d ) : dval( d ) {}
+        } val;
+public:
+        std::string rep;
+
+        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;
+        /// Gets the value of this constant as floating point
+        double floatValue() const;
+
+        /// generates a boolean constant of the given bool
+        static ConstantExpr * from_bool( const CodeLocation & loc, bool b );
+        /// generates a char constant of the given char
+        static ConstantExpr * from_char( const CodeLocation & loc, char c );
+        /// generates an integer constant of the given int
+        static ConstantExpr * from_int( const CodeLocation & loc, int i );
+        /// generates an integer constant of the given unsigned long int
+        static ConstantExpr * from_ulong( const CodeLocation & loc, unsigned long i );
+        /// generates a floating point constant of the given double
+        static ConstantExpr * from_double( const CodeLocation & loc, double d );
+        /// generates an array of chars constant of the given string
+        static ConstantExpr * from_string( const CodeLocation & loc, const std::string & s );
+        /// generates a null pointer value for the given type. void * if omitted.
+        static ConstantExpr * null( const CodeLocation & loc, const Type * ptrType = nullptr );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        ConstantExpr * clone() const override { return new ConstantExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// sizeof expression, e.g. `sizeof(int)`, `sizeof 3+4`
+class SizeofExpr final : public Expr {
+public:
+        ptr<Expr> expr;
+        ptr<Type> type;
+
+        SizeofExpr( const CodeLocation & loc, const Expr * e );
+        SizeofExpr( const CodeLocation & loc, const Type * t );
+        // deliberately no disambiguating overload for nullptr_t
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        SizeofExpr * clone() const override { return new SizeofExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// alignof expression, e.g. `alignof(int)`, `alignof 3+4`
+class AlignofExpr final : public Expr {
+public:
+        ptr<Expr> expr;
+        ptr<Type> type;
+
+        AlignofExpr( const CodeLocation & loc, const Expr * e );
+        AlignofExpr( const CodeLocation & loc, const Type * t );
+        // deliberately no disambiguating overload for nullptr_t
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        AlignofExpr * clone() const override { return new AlignofExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// offsetof expression before resolver determines field, e.g. `offsetof(MyStruct, myfield)`
+class UntypedOffsetofExpr final : public Expr {
+public:
+        ptr<Type> type;
+        std::string member;
+
+        UntypedOffsetofExpr( const CodeLocation & loc, const Type * ty, const std::string & mem )
+        : Expr( loc ), type( ty ), member( mem ) {}
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        UntypedOffsetofExpr * clone() const override { return new UntypedOffsetofExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// offsetof expression after resolver determines field, e.g. `offsetof(MyStruct, myfield)`
+class OffsetofExpr final : public Expr {
+public:
+        ptr<Type> type;
+        readonly<DeclWithType> member;
+
+        OffsetofExpr( const CodeLocation & loc, const Type * ty, const DeclWithType * mem );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        OffsetofExpr * clone() const override { return new OffsetofExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// a pack of field-offsets for a generic type
+class OffsetPackExpr final : public Expr {
+public:
+        ptr<StructInstType> type;
+
+        OffsetPackExpr( const CodeLocation & loc, const StructInstType * ty );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        OffsetPackExpr * clone() const override { return new OffsetPackExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// Variants of short-circuiting logical expression
+enum LogicalFlag { OrExpr, AndExpr };
+
+/// Short-circuiting boolean expression (`&&` or `||`)
+class LogicalExpr final : public Expr {
+public:
+        ptr<Expr> arg1;
+        ptr<Expr> arg2;
+        LogicalFlag isAnd;
+
+        LogicalExpr( const CodeLocation & loc, const Expr * a1, const Expr * a2, LogicalFlag ia );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        LogicalExpr * clone() const override { return new LogicalExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// Three-argument conditional e.g. `p ? a : b`
+class ConditionalExpr final : public Expr {
+public:
+        ptr<Expr> arg1;
+        ptr<Expr> arg2;
+        ptr<Expr> arg3;
+
+        ConditionalExpr( const CodeLocation & loc, const Expr * a1, const Expr * a2, const Expr * a3 )
+        : Expr( loc ), arg1( a1 ), arg2( a2 ), arg3( a3 ) {}
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        ConditionalExpr * clone() const override { return new ConditionalExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// Comma expression e.g. `( a , b )`
+class CommaExpr final : public Expr {
+public:
+        ptr<Expr> arg1;
+        ptr<Expr> arg2;
+
+        CommaExpr( const CodeLocation & loc, const Expr * a1, const Expr * a2 ) 
+        : Expr( loc ), arg1( a1 ), arg2( a2 ) {}
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        CommaExpr * clone() const override { return new CommaExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -136 +483 @@
 private:
         TypeExpr * clone() const override { return new TypeExpr{ *this }; }
-};
-
+        MUTATE_FRIEND
+};
+
+/// A GCC "asm constraint operand" used in an asm statement, e.g. `[output] "=f" (result)`.
+/// https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints
+class AsmExpr final : public Expr {
+public:
+        ptr<Expr> inout;
+        ptr<Expr> constraint; 
+};
 
 //=================================================================================================
@@ -146 +501 @@
 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 AttrExpr * node, Node::ref_type ref ) { node->increment(ref); }
-// inline void decrement( const class AttrExpr * 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 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); }
@@ -226 +579 @@
 }
 
+#undef MUTATE_FRIEND
+
 // Local Variables: //
 // tab-width: 4 //

src/AST/Fwd.hpp

@@ -77 +77 @@
 class OffsetofExpr;
 class OffsetPackExpr;
-class AttrExpr;
 class LogicalExpr;
 class ConditionalExpr;
@@ -252 +251 @@
 inline void increment( const class OffsetPackExpr *, Node::ref_type );
 inline void decrement( const class OffsetPackExpr *, Node::ref_type );
-inline void increment( const class AttrExpr *, Node::ref_type );
-inline void decrement( const class AttrExpr *, Node::ref_type );
 inline void increment( const class LogicalExpr *, Node::ref_type );
 inline void decrement( const class LogicalExpr *, Node::ref_type );

src/AST/Init.hpp

@@ -23 +23 @@
 #include "Visitor.hpp"
 
+// Must be included in *all* AST classes; should be #undef'd at the end of the file
+#define MUTATE_FRIEND template<typename node_t> friend auto mutate(const node_t * node);
+
 namespace ast {
 
@@ -40 +43 @@
 private:
         Designation* clone() const override { return new Designation{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -55 +59 @@
 private:
         const Init * clone() const override = 0;
+        MUTATE_FRIEND
 };
 
@@ -69 +74 @@
 private:
         SingleInit * clone() const override { return new SingleInit{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
@@ -97 +99 @@
 private:
         ListInit * clone() const override { return new ListInit{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
@@ -120 +119 @@
 private:
         ConstructorInit * clone() const override { return new ConstructorInit{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
@@ -142 +138 @@
 }
 
+#undef MUTATE_FRIEND
+
 // Local Variables: //
 // tab-width: 4 //

src/AST/Node.hpp

@@ -76 +76 @@
 // problems and be able to use auto return
 template<typename node_t>
-auto mutate(const node_t * node) {
+auto mutate( const node_t * node ) {
         assertf(
                 node->strong_count >= 1,
@@ -92 +92 @@
 }
 
-std::ostream& operator<< ( std::ostream& out, const Node* node );
+std::ostream& operator<< ( std::ostream& out, const Node * node );
 
 /// Base class for the smart pointer types
@@ -137 +137 @@
         operator const node_t * () const { return node; }
 
+        /// wrapper for convenient access to dynamic_cast
         template<typename o_node_t>
         const o_node_t * as() const { return dynamic_cast<const o_node_t *>(node); }
+
+        /// Sets this pointer to a mutated version of a pointer (possibly) owned elsehere.
+        /// Returns a mutable version of the pointer in this node.
+        node_t * set_and_mutate( const node_t * n ) {
+                // ensure ownership of `n` by this node to avoid spurious single-owner mutates
+                assign( n );
+                // get mutable version of `n`
+                auto r = mutate( node ); 
+                // re-assign mutable version in case `mutate()` produced a new pointer
+                assign( r );
+                return r;
+        }
 
         using ptr = const node_t *;

src/AST/Stmt.hpp

@@ -26 +26 @@
 #include "Common/CodeLocation.h"
 
+// Must be included in *all* AST classes; should be #undef'd at the end of the file
+#define MUTATE_FRIEND template<typename node_t> friend auto mutate(const node_t * node);
+
 namespace ast {
 
@@ -35 +38 @@
         std::vector<Label> labels;
 
-        Stmt( const CodeLocation& loc, std::vector<Label>&& labels = {} )
+        Stmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
         : ParseNode(loc), labels(std::move(labels)) {}
 
         Stmt(const Stmt& o) : ParseNode(o), labels(o.labels) {}
 
-        const Stmt* accept( Visitor& v ) const override = 0;
-private:
-        Stmt* clone() const override = 0;
+        const Stmt * accept( Visitor & v ) const override = 0;
+private:
+        Stmt * clone() const override = 0;
+        MUTATE_FRIEND
 };
 
@@ -50 +54 @@
         std::list<ptr<Stmt>> kids;
 
-        CompoundStmt(const CodeLocation& loc, std::list<ptr<Stmt>>&& ks = {} )
+        CompoundStmt(const CodeLocation & loc, std::list<ptr<Stmt>> && ks = {} )
         : Stmt(loc), kids(std::move(ks)) {}
 
@@ -56 +60 @@
         CompoundStmt( CompoundStmt&& o ) = default;
 
-        void push_back( Stmt* s ) { kids.emplace_back( s ); }
-        void push_front( Stmt* s ) { kids.emplace_front( s ); }
-
-        const CompoundStmt* accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        CompoundStmt* clone() const override { return new CompoundStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        void push_back( Stmt * s ) { kids.emplace_back( s ); }
+        void push_front( Stmt * s ) { kids.emplace_front( s ); }
+
+        const CompoundStmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        CompoundStmt * clone() const override { return new CompoundStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -71 +72 @@
 class NullStmt final : public Stmt {
 public:
-        NullStmt( const CodeLocation& loc, std::vector<Label>&& labels = {} )
+        NullStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
         : Stmt(loc, std::move(labels)) {}
 
-        const NullStmt* accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        NullStmt* clone() const override { return new NullStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        const NullStmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        NullStmt * clone() const override { return new NullStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -90 +88 @@
         ExprStmt( const CodeLocation & loc, const Expr * e ) : Stmt(loc), expr(e) {}
 
-        const Stmt * accept( Visitor& v ) const override { return v.visit( this ); }
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
         ExprStmt * clone() const override { return new ExprStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        MUTATE_FRIEND
 };
 
@@ -107 +102 @@
         std::vector<Label> gotoLabels;
 
-        AsmStmt( const CodeLocation& loc, bool isVolatile, const Expr * instruction,
-                std::vector<ptr<Expr>>&& output, std::vector<ptr<Expr>>&& input,
-                std::vector<ptr<ConstantExpr>>&& clobber, std::vector<Label>&& gotoLabels,
-                std::vector<Label>&& labels = {})
+        AsmStmt( const CodeLocation & loc, bool isVolatile, const Expr * instruction,
+                std::vector<ptr<Expr>> && output, std::vector<ptr<Expr>> && input,
+                std::vector<ptr<ConstantExpr>> && clobber, std::vector<Label> && gotoLabels,
+                std::vector<Label> && labels = {})
         : Stmt(loc, std::move(labels)), isVolatile(isVolatile), instruction(instruction),
           output(std::move(output)), input(std::move(input)), clobber(std::move(clobber)),
           gotoLabels(std::move(gotoLabels)) {}
 
-        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        AsmStmt* clone() const override { return new AsmStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        AsmStmt * clone() const override { return new AsmStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -128 +120 @@
         std::string directive;
 
-        DirectiveStmt( const CodeLocation& loc, const std::string & directive,
-                std::vector<Label>&& labels = {} )
+        DirectiveStmt( const CodeLocation & loc, const std::string & directive,
+                std::vector<Label> && labels = {} )
         : Stmt(loc, std::move(labels)), directive(directive) {}
 
-        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        DirectiveStmt* clone() const override { return new DirectiveStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        DirectiveStmt * clone() const override { return new DirectiveStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -148 +137 @@
         std::vector<ptr<Stmt>> inits;
 
-        IfStmt( const CodeLocation& loc, const Expr* cond, const Stmt* thenPart,
-                Stmt * const elsePart, std::vector<ptr<Stmt>>&& inits,
-                std::vector<Label>&& labels = {} )
+        IfStmt( const CodeLocation & loc, const Expr * cond, const Stmt * thenPart,
+                Stmt * const elsePart, std::vector<ptr<Stmt>> && inits,
+                std::vector<Label> && labels = {} )
         : Stmt(loc, std::move(labels)), cond(cond), thenPart(thenPart), elsePart(elsePart),
           inits(std::move(inits)) {}
 
-        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        IfStmt* clone() const override { return new IfStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        IfStmt * clone() const override { return new IfStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -168 +154 @@
         std::vector<ptr<Stmt>> stmts;
 
-        SwitchStmt( const CodeLocation& loc, const Expr* cond, std::vector<ptr<Stmt>>&& stmts,
-                std::vector<Label>&& labels = {} )
+        SwitchStmt( const CodeLocation & loc, const Expr * cond, std::vector<ptr<Stmt>> && stmts,
+                std::vector<Label> && labels = {} )
         : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
 
-        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        SwitchStmt* clone() const override { return new SwitchStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        SwitchStmt * clone() const override { return new SwitchStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -186 +169 @@
         std::vector<ptr<Stmt>> stmts;
 
-    CaseStmt( const CodeLocation& loc, const Expr* cond, std::vector<ptr<Stmt>>&& stmts,
-        std::vector<Label>&& labels = {} )
-    : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
+        CaseStmt( const CodeLocation & loc, const Expr * cond, std::vector<ptr<Stmt>> && stmts,
+                std::vector<Label> && labels = {} )
+        : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
 
         bool isDefault() { return !cond; }
 
-        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        CaseStmt* clone() const override { return new CaseStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        CaseStmt * clone() const override { return new CaseStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -208 +188 @@
         bool isDoWhile;
 
-        WhileStmt( const CodeLocation& loc, const Expr* cond, const Stmt* body,
-                std::vector<ptr<Stmt>>&& inits, bool isDoWhile = false, std::vector<Label>&& labels = {} )
+        WhileStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
+                std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, std::vector<Label> && labels = {} )
         : Stmt(loc, std::move(labels)), cond(cond), body(body), inits(std::move(inits)),
           isDoWhile(isDoWhile) {}
 
-        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        WhileStmt* clone() const override { return new WhileStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        WhileStmt * clone() const override { return new WhileStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -229 +206 @@
         ptr<Stmt> body;
 
-        ForStmt( const CodeLocation& loc, std::vector<ptr<Stmt>>&& inits, const Expr* cond,
-                const Expr* inc, const Stmt* body, std::vector<Label>&& labels = {} )
+        ForStmt( const CodeLocation & loc, std::vector<ptr<Stmt>> && inits, const Expr * cond,
+                const Expr * inc, const Stmt * body, std::vector<Label> && labels = {} )
         : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc),
           body(body) {}
 
-        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        ForStmt* clone() const override { return new ForStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        ForStmt * clone() const override { return new ForStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -253 +227 @@
         Kind kind;
 
-        BranchStmt( const CodeLocation& loc, Kind kind, Label target,
-                std::vector<Label>&& labels = {} );
-        BranchStmt( const CodeLocation& loc, const Expr* computedTarget,
-                std::vector<Label>&& labels = {} )
+        BranchStmt( const CodeLocation & loc, Kind kind, Label target,
+                std::vector<Label> && labels = {} );
+        BranchStmt( const CodeLocation & loc, const Expr * computedTarget,
+                std::vector<Label> && labels = {} )
         : Stmt(loc, std::move(labels)), originalTarget(loc), target(loc),
           computedTarget(computedTarget), kind(Goto) {}
@@ -262 +236 @@
         const char * kindName() { return kindNames[kind]; }
 
-        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        BranchStmt* clone() const override { return new BranchStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        BranchStmt * clone() const override { return new BranchStmt{ *this }; }
+        MUTATE_FRIEND
 
         static const char * kindNames[kindEnd];
@@ -277 +248 @@
         ptr<Expr> expr;
 
-        ReturnStmt( const CodeLocation& loc, const Expr* expr, std::vector<Label>&& labels = {} )
+        ReturnStmt( const CodeLocation & loc, const Expr * expr, std::vector<Label> && labels = {} )
         : Stmt(loc, std::move(labels)), expr(expr) {}
 
-        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        ReturnStmt* clone() const override { return new ReturnStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        ReturnStmt * clone() const override { return new ReturnStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -297 +265 @@
         Kind kind;
 
-        ThrowStmt( const CodeLocation& loc, Kind kind, const Expr* expr, const Expr* target,
-                std::vector<Label>&& labels = {} )
+        ThrowStmt( const CodeLocation & loc, Kind kind, const Expr * expr, const Expr * target,
+                std::vector<Label> && labels = {} )
         : Stmt(loc, std::move(labels)), expr(expr), target(target), kind(kind) {}
 
-        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        ThrowStmt* clone() const override { return new ThrowStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        ThrowStmt * clone() const override { return new ThrowStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -316 +281 @@
         ptr<FinallyStmt> finally;
 
-        TryStmt( const CodeLocation& loc, const CompoundStmt* body,
-                std::vector<ptr<CatchStmt>>&& handlers, const FinallyStmt* finally,
-                std::vector<Label>&& labels = {} )
+        TryStmt( const CodeLocation & loc, const CompoundStmt * body,
+                std::vector<ptr<CatchStmt>> && handlers, const FinallyStmt * finally,
+                std::vector<Label> && labels = {} )
         : Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}
 
-        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        TryStmt* clone() const override { return new TryStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        TryStmt * clone() const override { return new TryStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -339 +301 @@
         Kind kind;
 
-        CatchStmt( const CodeLocation& loc, Kind kind, const Decl* decl, const Expr* cond,
-                const Stmt* body, std::vector<Label>&& labels = {} )
+        CatchStmt( const CodeLocation & loc, Kind kind, const Decl * decl, const Expr * cond,
+                const Stmt * body, std::vector<Label> && labels = {} )
         : Stmt(loc, std::move(labels)), decl(decl), cond(cond), body(body), kind(kind) {}
 
-        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        CatchStmt* clone() const override { return new CatchStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        CatchStmt * clone() const override { return new CatchStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -356 +315 @@
         ptr<CompoundStmt> body;
 
-        FinallyStmt( const CodeLocation& loc, const CompoundStmt* body,
-                std::vector<Label>&& labels = {} )
+        FinallyStmt( const CodeLocation & loc, const CompoundStmt * body,
+                std::vector<Label> && labels = {} )
         : Stmt(loc, std::move(labels)), body(body) {}
 
-        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        FinallyStmt* clone() const override { return new FinallyStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        FinallyStmt * clone() const override { return new FinallyStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -397 +353 @@
         OrElse orElse;
 
-        WaitForStmt( const CodeLocation& loc, std::vector<Label>&& labels = {} )
+        WaitForStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
         : Stmt(loc, std::move(labels)) {}
 
-        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        WaitForStmt* clone() const override { return new WaitForStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        WaitForStmt * clone() const override { return new WaitForStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -414 +367 @@
         ptr<Stmt> stmt;
 
-        WithStmt( const CodeLocation& loc, std::vector<ptr<Expr>>&& exprs, const Stmt* stmt,
-                std::vector<Label>&& labels = {} )
+        WithStmt( const CodeLocation & loc, std::vector<ptr<Expr>> && exprs, const Stmt * stmt,
+                std::vector<Label> && labels = {} )
         : Stmt(loc, std::move(labels)), exprs(std::move(exprs)), stmt(stmt) {}
 
-        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        WithStmt* clone() const override { return new WithStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        WithStmt * clone() const override { return new WithStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -431 +381 @@
         ptr<Decl> decl;
 
-        DeclStmt( const CodeLocation& loc, const Decl* decl, std::vector<Label>&& labels = {} )
+        DeclStmt( const CodeLocation & loc, const Decl * decl, std::vector<Label> && labels = {} )
         : Stmt(loc, std::move(labels)), decl(decl) {}
 
-        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        DeclStmt* clone() const override { return new DeclStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        DeclStmt * clone() const override { return new DeclStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -447 +394 @@
         readonly<Stmt> callStmt;
 
-        ImplicitCtorDtorStmt( const CodeLocation& loc, const Stmt* callStmt,
-                std::vector<Label>&& labels = {} )
+        ImplicitCtorDtorStmt( const CodeLocation & loc, const Stmt * callStmt,
+                std::vector<Label> && labels = {} )
         : Stmt(loc, std::move(labels)), callStmt(callStmt) {}
 
-        const Stmt* accept( Visitor& v ) const override { return v.visit( this ); }
-private:
-        ImplicitCtorDtorStmt* clone() const override { return new ImplicitCtorDtorStmt{ *this }; }
-
-        /// Must be copied in ALL derived classes
-        template<typename node_t>
-        friend auto mutate(const node_t * node);
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        ImplicitCtorDtorStmt * clone() const override { return new ImplicitCtorDtorStmt{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -510 +454 @@
 }
 
+#undef MUTATE_FRIEND
+
 // Local Variables: //
 // tab-width: 4 //

src/AST/Type.hpp

@@ -29 +29 @@
 #include "Visitor.hpp"
 
+// Must be included in *all* AST classes; should be #undef'd at the end of the file
+#define MUTATE_FRIEND template<typename node_t> friend auto mutate(const node_t * node);
+
 namespace ast {
 
 class Type : public Node {
-        CV::Qualifiers tq;
-public:
-        Type( CV::Qualifiers q = {} ) : tq(q) {}
-
-        CV::Qualifiers qualifiers() const { return tq; }
-        bool is_const() const { return tq.is_const; }
-        bool is_volatile() const { return tq.is_volatile; }
-        bool is_restrict() const { return tq.is_restrict; }
-        bool is_lvalue() const { return tq.is_lvalue; }
-        bool is_mutex() const { return tq.is_mutex; }
-        bool is_atomic() const { return tq.is_atomic; }
-
-        void set_qualifiers( CV::Qualifiers q ) { tq = q; }
-        void set_const( bool v ) { tq.is_const = v; }
-        void set_restrict( bool v ) { tq.is_restrict = v; }
-        void set_lvalue( bool v ) { tq.is_lvalue = v; }
-        void set_mutex( bool v ) { tq.is_mutex = v; }
-        void set_atomic( bool v ) { tq.is_atomic = v; }
+public:
+        CV::Qualifiers qualifiers;
+        
+        Type( CV::Qualifiers q = {} ) : qualifiers(q) {}
+
+        bool is_const() const { return qualifiers.is_const; }
+        bool is_volatile() const { return qualifiers.is_volatile; }
+        bool is_restrict() const { return qualifiers.is_restrict; }
+        bool is_lvalue() const { return qualifiers.is_lvalue; }
+        bool is_mutex() const { return qualifiers.is_mutex; }
+        bool is_atomic() const { return qualifiers.is_atomic; }
+
+        void set_const( bool v ) { qualifiers.is_const = v; }
+        void set_restrict( bool v ) { qualifiers.is_restrict = v; }
+        void set_lvalue( bool v ) { qualifiers.is_lvalue = v; }
+        void set_mutex( bool v ) { qualifiers.is_mutex = v; }
+        void set_atomic( bool v ) { qualifiers.is_atomic = v; }
 
         /// How many elemental types are represented by this type
@@ -71 +73 @@
 private:
         virtual Type * clone() const override = 0;
+        MUTATE_FRIEND
 };
 
@@ -85 +88 @@
 private:
         VoidType * clone() const override { return new VoidType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -147 +151 @@
 private:
         BasicType * clone() const override { return new BasicType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -177 +182 @@
 private:
         PointerType * clone() const override { return new PointerType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -198 +204 @@
 private:
         ArrayType * clone() const override { return new ArrayType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -217 +224 @@
 private:
         ReferenceType * clone() const override { return new ReferenceType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -231 +239 @@
 private:
         QualifiedType * clone() const override { return new QualifiedType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -246 +255 @@
 private:
         virtual ParameterizedType * clone() const override = 0;
+        MUTATE_FRIEND
 };
 
@@ -254 +264 @@
 class FunctionType final : public ParameterizedType {
 public:
-        std::vector<ptr<DeclWithType>> returnVals;
-        std::vector<ptr<DeclWithType>> parameters;
+        std::vector<ptr<DeclWithType>> returns;
+        std::vector<ptr<DeclWithType>> params;
 
         /// Does the function accept a variable number of arguments following the arguments specified 
@@ -265 +275 @@
 
         FunctionType( ArgumentFlag va = FixedArgs, CV::Qualifiers q = {} )
-        : ParameterizedType(q), returnVals(), parameters(), isVarArgs(va) {}
+        : ParameterizedType(q), returns(), params(), isVarArgs(va) {}
 
         /// true if either the parameters or return values contain a tttype
         bool isTtype() const;
         /// true if function parameters are unconstrained by prototype
-        bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
+        bool isUnprototyped() const { return isVarArgs && params.size() == 0; }
 
         const Type * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
         FunctionType * clone() const override { return new FunctionType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -280 +291 @@
 class ReferenceToType : public ParameterizedType {
 public:
-        std::vector<ptr<Expr>> parameters;
+        std::vector<ptr<Expr>> params;
         std::vector<ptr<Attribute>> attributes;
         std::string name;
@@ -287 +298 @@
         ReferenceToType( const std::string& n, CV::Qualifiers q = {}, 
                 std::vector<ptr<Attribute>> && as = {} )
-        : ParameterizedType(q), parameters(), attributes(std::move(as)), name(n) {}
+        : ParameterizedType(q), params(), attributes(std::move(as)), name(n) {}
 
         /// Gets aggregate declaration this type refers to
@@ -296 +307 @@
 private:
         virtual ReferenceToType * clone() const override = 0;
+        MUTATE_FRIEND
 
 protected:
@@ -320 +332 @@
 private:
         StructInstType * clone() const override { return new StructInstType{ *this }; }
+        MUTATE_FRIEND
 
         std::string typeString() const override { return "struct"; }
@@ -342 +355 @@
 private:
         UnionInstType * clone() const override { return new UnionInstType{ *this }; }
+        MUTATE_FRIEND
 
         std::string typeString() const override { return "union"; }
@@ -364 +378 @@
 private:
         EnumInstType * clone() const override { return new EnumInstType{ *this }; }
+        MUTATE_FRIEND
 
         std::string typeString() const override { return "enum"; }
@@ -387 +402 @@
 private:
         TraitInstType * clone() const override { return new TraitInstType{ *this }; }
+        MUTATE_FRIEND
 
         std::string typeString() const override { return "trait"; }
@@ -415 +431 @@
 private:
         TypeInstType * clone() const override { return new TypeInstType{ *this }; }
+        MUTATE_FRIEND
 
         std::string typeString() const override { return "type"; }
@@ -443 +460 @@
 private:
         TupleType * clone() const override { return new TupleType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -457 +475 @@
 private:
         TypeofType * clone() const override { return new TypeofType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -467 +486 @@
 private:
         VarArgsType * clone() const override { return new VarArgsType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -476 +496 @@
         const Type * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
-        ZeroType * clone() const override { return new ZeroType{ *this }; }     
+        ZeroType * clone() const override { return new ZeroType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -487 +508 @@
 private:
         OneType * clone() const override { return new OneType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -497 +519 @@
 private:
         GlobalScopeType * clone() const override { return new GlobalScopeType{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -547 +570 @@
 }
 
+#undef MUTATE_FRIEND
+
 // Local Variables: //
 // tab-width: 4 //

src/AST/Visitor.hpp

@@ -69 +69 @@
     virtual const ast::Expr *             visit( const ast::OffsetofExpr         * ) = 0;
     virtual const ast::Expr *             visit( const ast::OffsetPackExpr       * ) = 0;
-    virtual const ast::Expr *             visit( const ast::AttrExpr             * ) = 0;
     virtual const ast::Expr *             visit( const ast::LogicalExpr          * ) = 0;
     virtual const ast::Expr *             visit( const ast::ConditionalExpr      * ) = 0;

src/AST/porting.md

@@ -6 +6 @@
   * specialization: strong pointer `ast::ptr<T>` is used for an ownership relationship
   * specialization: weak pointer `ast::readonly<T>` is used for an observation relationship
-  * added `ast::ptr_base<T,R>::as<S>()` with same semantics as `dynamic_cast<S*>(p)`
+* added `ast::ptr_base<T,R>::as<S>()` with same semantics as `dynamic_cast<S*>(p)`
+* added `N * ast::ptr_base<N,R>::set_and_mutate( const N * n )`
+  * takes ownership of `n`, then returns a mutable version owned by this pointer
+  * Some debate on whether this is a good approach:
+    * makes an easy path to cloning, which we were trying to eliminate
+      * counter-point: these are all mutating clones rather than lifetime-preserving clones, and thus "necessary" (for some definition)
+    * existing uses:
+      * `VariableExpr::VariableExpr`, `UntypedExpr::createDeref`
+        * both involve grabbing a type from elsewhere and making an `lvalue` copy of it
+        * could potentially be replaced by a view class something like this:
+          ```
+          template<unsigned Quals>
+          class AddQualifiersType final : public Type {
+            readonly<Type> base;
+            // ...
+          };
+          ```
+          * requires all `qualifiers` use (and related helpers) to be virtual, non-zero overhead
+          * also subtle semantic change, where mutations to the source decl now change the viewing expression
 
 ## Visitors ##
@@ -106 +124 @@
   * allows `newObject` as just default settings
 
+`NamedTypeDecl`
+* `parameters` => `params`
+
 `TypeDecl`
 * moved `TypeDecl::Kind` to `ast::TypeVar::Kind`
+
+`AggregateDecl`
+* `parameters` => `params`
 
 `EnumDecl`
@@ -115 +139 @@
 * Merged `inferParams`/`resnSlots` into union, as suggested by comment in old version
   * does imply get_/set_ API, and some care about moving backward
+* added constructor that sets result, for benefit of types that set it directly
+
+`ApplicationExpr`
+* `function` => `func`
+
+`UntypedExpr`
+* `function` => `func`
+* removed `begin_args()` in favour of `args.begin()`
+
+`MemberExpr`
+* **TODO** port setup of `result` in constructor
+
+`ConstantExpr`
+* inlined features of `Constant`, never used elsewhere, so removed `Constant`
+  * `Constant Constant::from_int(int)` etc. => `ConstantExpr * ConstantExpr::from_int(CodeLocation, int)`
+    * allocates new `ConstantExpr`, consistent with all existing uses
+
+`SizeofExpr`, `AlignofExpr`
+* `isType` deprecated in favour of boolean check on `type`
+  * all existing uses assume `type` set if true and don't use `expr`
+
+`AttrExpr`
+* did not port due to feature deprecation (e.g. `expr@attribute`)
+
+`LogicalExpr`
+* un-defaulted constructor parameter determining `&&` or `||`
 
 `Init`
@@ -148 +198 @@
 `Type`
 * `CV::Qualifiers` moved to end of constructor parameter list, defaulted to `{}`
+  * removed getter, setter in favour of public `qualifiers` field
   * `ReferenceToType` puts a defaulted list of attributes after qualifiers
 * `forall` field split off into `ParameterizedType` subclass
@@ -160 +211 @@
   * `getAggr()` => `aggr()`
     * also now returns `const AggregateDecl *`
-* `genericSubstitution()` moved to own visitor **TODO** write
+* `genericSubstitution()` moved to own visitor in `AST/GenericSubstitution.hpp` **TODO** write
 
 `BasicType`
@@ -167 +218 @@
 `ReferenceToType`
 * deleted `get_baseParameters()` from children
-  * replace with `aggr() ? aggr()->parameters : nullptr`
+  * replace with `aggr() ? aggr()->params : nullptr`
+* `parameters` => `params`
 * hoisted `lookup` implementation into parent, made non-virtual
   * also changed to return vector rather than filling; change back if any great win for reuse
@@ -178 +230 @@
 
 `FunctionType`
+* `returnVals` => `returns`
+* `parameters` => `params`
 * `bool isVarArgs;` => `enum ArgumentFlag { FixedArgs, VariableArgs }; ArgumentFlag isVarArgs;`
 

src/ResolvExpr/Unify.cc

@@ -21 +21 @@
 #include <string>                 // for string, operator==, operator!=, bas...
 #include <utility>                // for pair, move
-
+#include <vector>
+
+#include "AST/Node.hpp"
+#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"   // for PassVisitor
 #include "FindOpenVars.h"         // for findOpenVars
@@ -630 +633 @@
         }
 
-        // xxx - compute once and store in the FunctionType?
         Type * extractResultType( FunctionType * function ) {
                 if ( function->get_returnVals().size() == 0 ) {
@@ -644 +646 @@
                 }
         }
+
+        ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func ) {
+                assert(!"restore after AST added to build");
+                // if ( func->returns.empty() ) return new ast::VoidType{};
+                // if ( func->returns.size() == 1 ) return func->returns[0]->get_type();
+
+                // std::vector<ast::ptr<ast::Type>> tys;
+                // for ( const ast::DeclWithType * decl : func->returns ) {
+                //      tys.emplace_back( decl->get_type() );
+                // }
+                // return new ast::TupleType{ std::move(tys) };
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/typeops.h

@@ -18 +18 @@
 #include <vector>
 
+#include "AST/Node.hpp"
+#include "AST/Type.hpp"
 #include "SynTree/SynTree.h"
 #include "SynTree/Type.h"
@@ -99 +101 @@
         /// creates the type represented by the list of returnVals in a FunctionType. The caller owns the return value.
         Type * extractResultType( FunctionType * functionType );
+        /// Creates or extracts the type represented by the list of returns in a `FunctionType`.
+        ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func );
 
         // in CommonType.cc