Changeset 54e41b3

Timestamp:

May 16, 2019, 1:46:28 PM (6 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:

24afc53

Parents:

89c2f7c9

Message:

Add first half of ast::Expr subclasses

Location:

src

Files:

• AST/Convert.cpp (modified) (1 diff)
• AST/Decl.hpp (modified) (4 diffs)
• AST/Expr.cpp (added)
• AST/Expr.hpp (modified) (5 diffs)
• AST/Fwd.hpp (modified) (2 diffs)
• AST/Node.hpp (modified) (3 diffs)
• AST/Type.hpp (modified) (5 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/Convert.cpp

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

src/AST/Decl.hpp

@@ -32 +32 @@
 namespace ast {
 
-class Attribute;
-class Expr;
-class Init;
-class TypeDecl;
-
 /// Base declaration class
 class Decl : public ParseNode {
@@ -149 +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
@@ -230 +225 @@
 public:
         std::vector<ptr<Decl>> members;
-        std::vector<ptr<TypeDecl>> parameters;
+        std::vector<ptr<TypeDecl>> params;
         std::vector<ptr<Attribute>> attributes;
         bool body = false;
@@ -237 +232 @@
         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) ) {}
 

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"
@@ -117 +119 @@
         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 +127 @@
 private:
         Expr * clone() const override = 0;
+};
+
+/// 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 }; }
+};
+
+/// 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 }; }
+};
+
+/// 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 }; }
+};
+
+/// 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 }; }
+};
+
+/// 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 }; }
+};
+
+/// 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 }; }
+};
+
+/// 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 }; }
+};
+
+/// 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 }; }
+};
+
+/// 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 }; }
+};
+
+/// 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 }; }
+};
+
+/// 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 }; }
+};
+
+/// 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 }; }
+};
+
+/// 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 }; }
+};
+
+/// 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 }; }
+};
+
+/// 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 }; }
+};
+
+/// 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 }; }
+};
+
+/// 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 }; }
+};
+
+/// 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 }; }
+};
+
+/// 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 }; }
+};
+
+/// 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 }; }
 };
 
@@ -138 +461 @@
 };
 
+/// 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 +476 @@
 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); }

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/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/Type.hpp

@@ -32 +32 @@
 
 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
@@ -254 +253 @@
 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 +264 @@
 
         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 ); }
@@ -280 +279 @@
 class ReferenceToType : public ParameterizedType {
 public:
-        std::vector<ptr<Expr>> parameters;
+        std::vector<ptr<Expr>> params;
         std::vector<ptr<Attribute>> attributes;
         std::string name;
@@ -287 +286 @@
         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

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