Changeset b067d9b for src/SynTree

Timestamp:

Oct 29, 2019, 4:01:24 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

773db65, 9421f3d8

Parents:

7951100 (diff), 8364209 (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/SynTree

Files:

• AddressExpr.cc (modified) (2 diffs)
• AggregateDecl.cc (modified) (2 diffs)
• ApplicationExpr.cc (modified) (4 diffs)
• ArrayType.cc (modified) (1 diff)
• Attribute.cc (modified) (1 diff)
• Attribute.h (modified) (1 diff)
• BaseSyntaxNode.h (modified) (4 diffs)
• BasicType.cc (modified) (2 diffs)
• CommaExpr.cc (modified) (3 diffs)
• Constant.cc (modified) (5 diffs)
• Constant.h (modified) (4 diffs)
• DeclReplacer.cc (modified) (5 diffs)
• DeclReplacer.h (modified) (1 diff)
• Declaration.cc (modified) (2 diffs)
• Declaration.h (modified) (17 diffs)
• Expression.cc (modified) (52 diffs)
• Expression.h (modified) (53 diffs)
• FunctionDecl.cc (modified) (1 diff)
• FunctionType.cc (modified) (1 diff)
• Initializer.h (modified) (5 diffs)
• Label.h (modified) (1 diff)
• Mutator.h (modified) (7 diffs)
• ObjectDecl.cc (modified) (1 diff)
• ReferenceToType.cc (modified) (7 diffs)
• Statement.cc (modified) (1 diff)
• Statement.h (modified) (23 diffs)
• SynTree.h (modified) (8 diffs)
• TupleExpr.cc (modified) (5 diffs)
• Type.cc (modified) (6 diffs)
• Type.h (modified) (30 diffs)
• TypeSubstitution.cc (modified) (3 diffs)
• TypeSubstitution.h (modified) (11 diffs)
• TypeofType.cc (modified) (2 diffs)
• Visitor.h (modified) (3 diffs)
• module.mk (modified) (1 diff)

src/SynTree/AddressExpr.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 23:54:44 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Tue Apr 26 12:35:13 2016
-// Update Count     : 6
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Feb 28 13:13:38 2019
+// Update Count     : 10
 //
 
@@ -42 +42 @@
 AddressExpr::AddressExpr( Expression *arg ) : Expression(), arg( arg ) {
         if ( arg->result ) {
-                if ( arg->result->get_lvalue() ) {
+                if ( arg->get_lvalue() ) {
                         // lvalue, retains all layers of reference and gains a pointer inside the references
                         set_result( addrType( arg->result ) );
                 } else {
                         // taking address of non-lvalue -- must be a reference, loses one layer of reference
-                        ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( arg->result );
-                        set_result( addrType( refType->base ) );
+                        if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( arg->result ) ) {
+                                set_result( addrType( refType->base ) );
+                        } else {
+                                SemanticError( arg->result, "Attempt to take address of non-lvalue expression: " );
+                        } // if
                 }
-                // result of & is never an lvalue
-                get_result()->set_lvalue( false );
         }
 }

src/SynTree/AggregateDecl.cc

@@ -86 +86 @@
 std::string TraitDecl::typeString() const { return "trait"; }
 
-namespace {
-        long long int getConstValue( Expression * expr ) {
-                if ( CastExpr * castExpr = dynamic_cast< CastExpr * > ( expr ) ) {
-                        return getConstValue( castExpr->arg );
-                } else if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) {
-                        return constExpr->intValue();
-                // can be -1, +1, etc.
-                // } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( expr ) ) {
-                //      if ( untypedExpr-> )
-                } else {
-                        assertf( false, "Unhandled expression type in getConstValue for enumerators: %s", toString( expr ).c_str() );
-                }
-        }
-}
-
 bool EnumDecl::valueOf( Declaration * enumerator, long long int & value ) {
         if ( enumValues.empty() ) {
@@ -108 +93 @@
                         if ( field->init ) {
                                 SingleInit * init = strict_dynamic_cast< SingleInit * >( field->init );
-                                currentValue = getConstValue( init->value );
+                                auto result = eval( init->value );
+                                if ( ! result.second ) SemanticError( init->location, toString( "Non-constexpr in initialization of enumerator: ", field ) );
+                                currentValue = result.first;
                         }
                         assertf( enumValues.count( field->name ) == 0, "Enum %s has multiple members with the name %s", name.c_str(), field->name.c_str() );

src/SynTree/ApplicationExpr.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Tue Apr 26 12:41:06 2016
-// Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Aug 12 14:28:00 2019
+// Update Count     : 5
 //
 
@@ -25 +25 @@
 #include "Declaration.h"         // for Declaration
 #include "Expression.h"          // for ParamEntry, ApplicationExpr, Expression
+#include "InitTweak/InitTweak.h" // for getFunction
 #include "ResolvExpr/typeops.h"  // for extractResultType
 #include "Type.h"                // for Type, PointerType, FunctionType
 
+ParamEntry::ParamEntry( UniqueId decl, Declaration * declptr, Type * actualType, Type * formalType, Expression* expr )
+                : decl( decl ), declptr( declptr ), actualType( actualType ), formalType( formalType ), expr( expr ) {
+        }
+
 ParamEntry::ParamEntry( const ParamEntry &other ) :
-                decl( other.decl ), actualType( maybeClone( other.actualType ) ), formalType( maybeClone( other.formalType ) ), expr( maybeClone( other.expr ) ), inferParams( new InferredParams( *other.inferParams ) ) {
-}
-
-ParamEntry &ParamEntry::operator=( const ParamEntry &other ) {
-        if ( &other == this ) return *this;
-        decl = other.decl;
-        // xxx - this looks like a memory leak
-        actualType = maybeClone( other.actualType );
-        formalType = maybeClone( other.formalType );
-        expr = maybeClone( other.expr );
-        *inferParams = *other.inferParams;
-        return *this;
+                decl( other.decl ), declptr( maybeClone( other.declptr ) ), actualType( maybeClone( other.actualType ) ), formalType( maybeClone( other.formalType ) ), expr( maybeClone( other.expr ) ) {
 }
 
 ParamEntry::~ParamEntry() {
+        delete declptr;
         delete actualType;
         delete formalType;
@@ -50 +45 @@
 
 ParamEntry::ParamEntry( ParamEntry && other ) :
-                decl( other.decl ), actualType( other.actualType ), formalType( other.formalType ), expr( other.expr ), inferParams( std::move( other.inferParams ) ) {
-        other.actualType = nullptr;
-        other.formalType = nullptr;
-        other.expr = nullptr;
+                decl( other.decl ), declptr( other.declptr ), actualType( other.actualType ), formalType( other.formalType ), expr( other.expr ) {
+        new (&other) ParamEntry();
 }
 
 ParamEntry & ParamEntry::operator=( ParamEntry && other ) {
         if ( &other == this ) return *this;
-        delete actualType;
-        delete formalType;
-        delete expr;
-        decl = other.decl;
-        actualType = other.actualType;
-        formalType = other.formalType;
-        expr = other.expr;
-        other.actualType = nullptr;
-        other.formalType = nullptr;
-        other.expr = nullptr;
-        inferParams = std::move( other.inferParams );
+        this->~ParamEntry();
+        new (this) ParamEntry(other.decl, other.declptr, other.actualType, other.formalType, other.expr);
+        new (&other) ParamEntry();
+
         return *this;
 }
@@ -91 +77 @@
 }
 
+bool ApplicationExpr::get_lvalue() const {
+        // from src/GenPoly/Lvalue.cc: isIntrinsicReference
+        static std::set<std::string> lvalueFunctions = { "*?", "?[?]" };
+        if ( const DeclarationWithType * func = InitTweak::getFunction( this ) ) {
+                return func->linkage == LinkageSpec::Intrinsic && lvalueFunctions.count(func->name);
+        }
+        return false;
+}
+
 void ApplicationExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Application of" << std::endl << indent+1;

src/SynTree/ArrayType.cc

@@ -26 +26 @@
 ArrayType::ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes )
         : Type( tq, attributes ), base( base ), dimension( dimension ), isVarLen( isVarLen ), isStatic( isStatic ) {
-        base->set_lvalue( false );
 }
 

src/SynTree/Attribute.cc

@@ -21 +21 @@
 #include "Expression.h"      // for Expression
 
-Attribute::Attribute( const Attribute &other ) : name( other.name ) {
+Attribute::Attribute( const Attribute &other ) : BaseSyntaxNode( other ), name( other.name ) {
         cloneAll( other.parameters, parameters );
 }

src/SynTree/Attribute.h

@@ -50 +50 @@
         Attribute * clone() const override { return new Attribute( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Attribute * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;

src/SynTree/BaseSyntaxNode.h

@@ -9 +9 @@
 // Author           : Thierry Delisle
 // Created On       : Tue Feb 14 07:44:20 2017
-// Last Modified By : Andrew Beach
-// Last Modified On : Thr Aug 17 13:44:00
-// Update Count     : 1
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Jul 10 16:13:49 2019
+// Update Count     : 4
 //
 
@@ -18 +18 @@
 #include "Common/CodeLocation.h"
 #include "Common/Indenter.h"
+#include "Common/Stats.h"
+
 class Visitor;
 class Mutator;
@@ -23 +25 @@
 class BaseSyntaxNode {
   public:
+        static Stats::Counters::SimpleCounter* new_nodes;
+
         CodeLocation location;
+
+        BaseSyntaxNode() { ++*new_nodes; }
+        BaseSyntaxNode( const BaseSyntaxNode & o ) : location(o.location) { ++*new_nodes; }
+        BaseSyntaxNode & operator=( const BaseSyntaxNode & ) = default;
 
         virtual ~BaseSyntaxNode() {}
@@ -29 +37 @@
         virtual BaseSyntaxNode * clone() const = 0;
         virtual void accept( Visitor & v ) = 0;
+        virtual void accept( Visitor & v ) const = 0;
         virtual BaseSyntaxNode * acceptMutator( Mutator & m ) = 0;
-  /// Notes:
-  /// * each node is responsible for indenting its children.
-  /// * Expressions should not finish with a newline, since the expression's parent has better information.
+        /// Notes:
+        /// * each node is responsible for indenting its children.
+        /// * Expressions should not finish with a newline, since the expression's parent has better information.
         virtual void print( std::ostream & os, Indenter indent = {} ) const = 0;
-  void print( std::ostream & os, unsigned int indent ) {
-    print( os, Indenter{ Indenter::tabsize, indent });
-  }
 };
 

src/SynTree/BasicType.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 25 14:14:03 2017
-// Update Count     : 11
+// Last Modified On : Sun Aug  4 21:07:44 2019
+// Update Count     : 13
 //
 
@@ -30 +30 @@
 
 bool BasicType::isInteger() const {
-        switch ( kind ) {
-          case Bool:
-          case Char:
-          case SignedChar:
-          case UnsignedChar:
-          case ShortSignedInt:
-          case ShortUnsignedInt:
-          case SignedInt:
-          case UnsignedInt:
-          case LongSignedInt:
-          case LongUnsignedInt:
-          case LongLongSignedInt:
-          case LongLongUnsignedInt:
-          case SignedInt128:
-          case UnsignedInt128:
-                return true;
-          case Float:
-          case Double:
-          case LongDouble:
-          case FloatComplex:
-          case DoubleComplex:
-          case LongDoubleComplex:
-          case FloatImaginary:
-          case DoubleImaginary:
-          case LongDoubleImaginary:
-          case Float80:
-          case Float128:
-                return false;
-          case NUMBER_OF_BASIC_TYPES:
-                assert( false );
-        } // switch
-        assert( false );
-        return false;
+        return kind <= UnsignedInt128;
 }
 

src/SynTree/CommaExpr.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Mon May 02 15:19:44 2016
-// Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Arg 12 16:11:00 2016
+// Update Count     : 2
 //
 
@@ -23 +23 @@
 CommaExpr::CommaExpr( Expression *arg1, Expression *arg2 )
                 : Expression(), arg1( arg1 ), arg2( arg2 ) {
-        // xxx - result of a comma expression is never an lvalue, so should set lvalue
-        // to false on all result types. Actually doing this causes some strange things
-        // to happen in later passes (particularly, Specialize, Lvalue, and Box). This needs to be looked into.
         set_result( maybeClone( arg2->get_result() ) );
-        // get_type->set_isLvalue( false );
 }
 
@@ -37 +33 @@
         delete arg1;
         delete arg2;
+}
+
+bool CommaExpr::get_lvalue() const {
+        // This is wrong by C, but the current implementation uses it.
+        // (ex: Specialize, Lvalue and Box)
+        return arg2->get_lvalue();
 }
 

src/SynTree/Constant.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Fri Jul 14 14:50:00 2017
-// Update Count     : 29
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Feb 13 18:11:22 2019
+// Update Count     : 32
 //
 
@@ -19 +19 @@
 
 #include "Constant.h"
+#include "Expression.h" // for ConstantExpr
 #include "Type.h"    // for BasicType, Type, Type::Qualifiers, PointerType
 
-Constant::Constant( Type * type, std::string rep, unsigned long long val ) : type( type ), rep( rep ), val( val ) {}
-Constant::Constant( Type * type, std::string rep, double val ) : type( type ), rep( rep ), val( val ) {}
+Constant::Constant( Type * type, std::string rep, std::optional<unsigned long long> ival ) : type( type ), rep( rep ), ival( ival ) {}
 
-Constant::Constant( const Constant &other ) : rep( other.rep ), val( other.val ) {
+Constant::Constant( const Constant &other ) : BaseSyntaxNode( other ), rep( other.rep ), ival( other.ival ) {
         type = other.type->clone();
 }
@@ -34 +34 @@
 }
 
-Constant Constant::from_char( char c ) {
-        return Constant( new BasicType( Type::Qualifiers(), BasicType::Char ), std::to_string( c ), (unsigned long long int)c );
-}
-
 Constant Constant::from_int( int i ) {
         return Constant( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), std::to_string( i ), (unsigned long long int)i );
@@ -44 +40 @@
 Constant Constant::from_ulong( unsigned long i ) {
         return Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), std::to_string( i ), (unsigned long long int)i );
-}
-
-Constant Constant::from_double( double d ) {
-        return Constant( new BasicType( Type::Qualifiers(), BasicType::Double ), std::to_string( d ), d );
 }
 
@@ -63 +55 @@
 unsigned long long Constant::get_ival() const {
         assertf( strict_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve ival from non-integer constant." );
-        return val.ival;
-}
-
-double Constant::get_dval() const {
-        assertf( ! strict_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve dval from integer constant." );
-        return val.dval;
+        return ival.value();
 }
 
 void Constant::print( std::ostream &os, Indenter ) const {
-        os << "(" << rep << " " << val.ival;
+        os << "(" << rep << " " << (ival ? toString(ival.value()) : "") ;
         if ( type ) {
                 os << ": ";

src/SynTree/Constant.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:54:46 2017
-// Update Count     : 17
+// Last Modified On : Wed Jul 10 15:57:38 2019
+// Update Count     : 19
 //
 
@@ -18 +18 @@
 #include <iosfwd>     // for ostream
 #include <string>     // for string
+#include <optional>   // for optional
 
 #include "BaseSyntaxNode.h"
@@ -27 +28 @@
 class Constant : public BaseSyntaxNode {
   public:
-        Constant( Type * type, std::string rep, unsigned long long val );
-        Constant( Type * type, std::string rep, double val );
+        Constant( Type * type, std::string rep, std::optional<unsigned long long> i );
         Constant( const Constant & other );
+        Constant & operator=( const Constant & ) = default;
         virtual ~Constant();
 
-        virtual Constant * clone() const { return new Constant( *this ); }
+        virtual Constant * clone() const override { return new Constant( *this ); }
 
         Type * get_type() { return type; }
@@ -39 +40 @@
         void set_value( std::string newValue ) { rep = newValue; }
         unsigned long long get_ival() const;
-        double get_dval() const;
 
         /// generates a boolean constant of the given bool
         static Constant from_bool( bool b );
-        /// generates a char constant of the given char
-        static Constant from_char( char c );
         /// generates an integer constant of the given int
         static Constant from_int( int i );
         /// generates an integer constant of the given unsigned long int
         static Constant from_ulong( unsigned long i );
-        /// generates a floating point constant of the given double
-        static Constant from_double( double d );
 
         /// generates a null pointer value for the given type. void * if omitted.
         static Constant null( Type * ptrtype = nullptr );
 
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Constant * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = 0 ) const;
-  private:
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Constant * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = 0 ) const override;
+
         Type * type;
         std::string rep;
-        union Val {
-                unsigned long long ival;
-                double dval;
-                Val( unsigned long long ival ) : ival( ival ) {}
-                Val( double dval ) : dval( dval ) {}
-        } val;
+        std::optional<unsigned long long> ival;
 };
 

src/SynTree/DeclReplacer.cc

@@ -30 +30 @@
                         bool debug;
                 public:
+                        size_t replaced;
+
+                public:
                         DeclReplacer( const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
 
@@ -38 +41 @@
                         void previsit( TypeInstType * inst );
                 };
+
+                /// Mutator that replaces uses of declarations with arbitrary expressions, according to the supplied mapping
+                struct ExprDeclReplacer {
+                private:
+                        const ExprMap & exprMap;
+                        bool debug;
+                public:
+                        size_t replaced;
+
+                public:
+                        ExprDeclReplacer( const ExprMap & exprMap, bool debug = false );
+
+                        // replace variable with new node from expr map
+                        Expression * postmutate( VariableExpr * varExpr );
+                };
         }
 
-        void replace( BaseSyntaxNode * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug ) {
+        size_t replace( BaseSyntaxNode * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug ) {
                 PassVisitor<DeclReplacer> replacer( declMap, typeMap, debug );
                 maybeAccept( node, replacer );
+                return replacer.pass.replaced;
         }
 
-        void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug ) {
+        size_t replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug ) {
                 TypeMap typeMap;
-                replace( node, declMap, typeMap, debug );
+                return replace( node, declMap, typeMap, debug );
         }
 
-        void replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug ) {
+        size_t replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug ) {
                 DeclMap declMap;
-                replace( node, declMap, typeMap, debug );
+                return replace( node, declMap, typeMap, debug );
+        }
+
+        size_t replace( BaseSyntaxNode *& node, const ExprMap & exprMap, bool debug ) {
+                PassVisitor<ExprDeclReplacer> replacer( exprMap, debug );
+                node = maybeMutate( node, replacer );
+                return replacer.pass.replaced;
         }
 
         namespace {
-                DeclReplacer::DeclReplacer( const DeclMap & declMap, const TypeMap & typeMap, bool debug ) : declMap( declMap ), typeMap( typeMap ) , debug( debug ) {}
+                DeclReplacer::DeclReplacer( const DeclMap & declMap, const TypeMap & typeMap, bool debug ) : declMap( declMap ), typeMap( typeMap ) , debug( debug ), replaced( 0 ) {}
 
                 // replace variable with new node from decl map
@@ -62 +87 @@
                         // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
                         if ( declMap.count( varExpr->var ) ) {
+                                replaced++;
                                 auto replacement = declMap.at( varExpr->var );
                                 if ( debug ) {
@@ -72 +98 @@
                 void DeclReplacer::previsit( TypeInstType * inst ) {
                         if ( typeMap.count( inst->baseType ) ) {
+                                replaced++;
                                 auto replacement = typeMap.at( inst->baseType );
                                 if ( debug ) {
@@ -79 +106 @@
                         }
                 }
+
+                ExprDeclReplacer::ExprDeclReplacer( const ExprMap & exprMap, bool debug ) : exprMap( exprMap ), debug( debug ), replaced( 0 ) {}
+
+                Expression * ExprDeclReplacer::postmutate( VariableExpr * varExpr ) {
+                        if ( exprMap.count( varExpr->var ) ) {
+                                replaced++;
+                                Expression * replacement = exprMap.at( varExpr->var )->clone();
+                                if ( debug ) {
+                                        std::cerr << "replacing variable reference: " << (void*)varExpr->var << " " << varExpr->var << " with " << (void*)replacement << " " << replacement << std::endl;
+                                }
+                                std::swap( varExpr->env, replacement->env );
+                                delete varExpr;
+                                return replacement;
+                        }
+                        return varExpr;
+                }
         }
 } // namespace VarExprReplacer

src/SynTree/DeclReplacer.h

@@ -26 +26 @@
         typedef std::map< DeclarationWithType *, DeclarationWithType * > DeclMap;
         typedef std::map< TypeDecl *, TypeDecl * > TypeMap;
+        typedef std::map< DeclarationWithType *, Expression * > ExprMap;
 
-        void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false );
-        void replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug = false );
-        void replace( BaseSyntaxNode * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
+        size_t replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false );
+        size_t replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug = false );
+        size_t replace( BaseSyntaxNode * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
+
+        size_t replace( BaseSyntaxNode *& node, const ExprMap & exprMap, bool debug = false);
+
+        template<typename T>
+        size_t replace( T *& node, const ExprMap & exprMap, bool debug = false ) {
+                if ( ! node ) return 0ul;
+                BaseSyntaxNode * arg = node;
+                size_t replaced = replace( arg, exprMap, debug );
+                node = dynamic_cast<T *>( arg );
+                assertf( node, "DeclReplacer fundamentally changed the type of its argument." );
+                return replaced;
+        }
 }
 

src/SynTree/Declaration.cc

@@ -27 +27 @@
 
 static UniqueId lastUniqueId = 0;
-typedef std::map< UniqueId, Declaration* > IdMapType;
-static IdMapType idMap;
 
 Declaration::Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage )
-                : name( name ), linkage( linkage ), storageClasses( scs ), uniqueId( 0 ) {
+                : name( name ), linkage( linkage ), uniqueId( 0 ), storageClasses( scs ) {
 }
 
 Declaration::Declaration( const Declaration &other )
-        : BaseSyntaxNode( other ), name( other.name ), linkage( other.linkage ), extension( other.extension ), storageClasses( other.storageClasses ), uniqueId( other.uniqueId ) {
+        : BaseSyntaxNode( other ), name( other.name ), linkage( other.linkage ), extension( other.extension ), uniqueId( other.uniqueId ), storageClasses( other.storageClasses ) {
 }
 
@@ -45 +43 @@
         if ( uniqueId ) return;
         uniqueId = ++lastUniqueId;
-        idMap[ uniqueId ] = this;
 }
-
-Declaration *Declaration::declFromId( UniqueId id ) {
-        IdMapType::const_iterator i = idMap.find( id );
-        return i != idMap.end() ? i->second : 0;
-}
-
-void Declaration::dumpIds( std::ostream &os ) {
-        for ( IdMapType::const_iterator i = idMap.begin(); i != idMap.end(); ++i ) {
-                os << i->first << " -> ";
-                i->second->printShort( os );
-                os << std::endl;
-        } // for
-}
-
 
 AsmDecl::AsmDecl( AsmStmt *stmt ) : Declaration( "", Type::StorageClasses(), LinkageSpec::C ), stmt( stmt ) {

src/SynTree/Declaration.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Sep  3 19:24:06 2017
-// Update Count     : 131
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr May  2 10:47:00 2019
+// Update Count     : 135
 //
 
@@ -19 +19 @@
 #include <iosfwd>                // for ostream
 #include <list>                  // for list
+#include <unordered_map>         // for unordered_map
 #include <string>                // for string, operator+, allocator, to_string
 
@@ -62 +63 @@
         void fixUniqueId( void );
         virtual Declaration *clone() const override = 0;
-        virtual void accept( Visitor &v ) override = 0;
+        virtual void accept( Visitor & v ) override = 0;
+        virtual void accept( Visitor & v ) const override = 0;
         virtual Declaration *acceptMutator( Mutator &m ) override = 0;
         virtual void print( std::ostream &os, Indenter indent = {} ) const override = 0;
         virtual void printShort( std::ostream &os, Indenter indent = {} ) const = 0;
 
-        static void dumpIds( std::ostream &os );
-        static Declaration *declFromId( UniqueId id );
-
-  private:
+        UniqueId uniqueId;
         Type::StorageClasses storageClasses;
-        UniqueId uniqueId;
+  private:
 };
 
@@ -141 +140 @@
 
         virtual ObjectDecl *clone() const override { return new ObjectDecl( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
@@ -166 +166 @@
         CompoundStmt *get_statements() const { return statements; }
         void set_statements( CompoundStmt *newValue ) { statements = newValue; }
+        bool has_body() const { return NULL != statements; }
 
         static FunctionDecl * newFunction( const std::string & name, FunctionType * type, CompoundStmt * statements );
 
         virtual FunctionDecl *clone() const override { return new FunctionDecl( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
@@ -202 +204 @@
         typedef NamedTypeDecl Parent;
   public:
-        enum Kind { Dtype, Ftype, Ttype };
+        enum Kind { Dtype, Ftype, Ttype, NUMBER_OF_KINDS };
 
         Type * init;
@@ -211 +213 @@
                 TypeDecl::Kind kind;
                 bool isComplete;
+
                 Data() : kind( (TypeDecl::Kind)-1 ), isComplete( false ) {}
                 Data( TypeDecl * typeDecl ) : Data( typeDecl->get_kind(), typeDecl->isComplete() ) {}
                 Data( Kind kind, bool isComplete ) : kind( kind ), isComplete( isComplete ) {}
+                Data( const Data& d1, const Data& d2 )
+                : kind( d1.kind ), isComplete ( d1.isComplete || d2.isComplete ) {}
+
                 bool operator==(const Data & other) const { return kind == other.kind && isComplete == other.isComplete; }
                 bool operator!=(const Data & other) const { return !(*this == other);}
@@ -235 +241 @@
 
         virtual TypeDecl *clone() const override { return new TypeDecl( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
-
-  private:
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+
         Kind kind;
 };
@@ -254 +260 @@
 
         virtual TypedefDecl *clone() const override { return new TypedefDecl( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
   private:
@@ -266 +273 @@
         bool body;
         std::list< Attribute * > attributes;
+        AggregateDecl * parent = nullptr;
 
         AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall );
@@ -280 +288 @@
         AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
 
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override final;
         virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
   protected:
@@ -297 +305 @@
 
         virtual StructDecl *clone() const override { return new StructDecl( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-  private:
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
         DeclarationNode::Aggregate kind;
+  private:
         virtual std::string typeString() const override;
 };
@@ -311 +320 @@
 
         virtual UnionDecl *clone() const override { return new UnionDecl( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
   private:
@@ -326 +336 @@
 
         virtual EnumDecl *clone() const override { return new EnumDecl( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-  private:
-        std::map< std::string, long long int > enumValues;
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
+        std::unordered_map< std::string, long long int > enumValues;
         virtual std::string typeString() const override;
 };
@@ -342 +353 @@
 
         virtual TraitDecl *clone() const override { return new TraitDecl( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-  private:
-        virtual std::string typeString() const override;
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const override;
+};
+
+class WithStmt : public Declaration {
+public:
+        std::list< Expression * > exprs;
+        Statement * stmt;
+
+        WithStmt( const std::list< Expression * > & exprs, Statement * stmt );
+        WithStmt( const WithStmt & other );
+        virtual ~WithStmt();
+
+        virtual WithStmt * clone() const override { return new WithStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Declaration * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream & os, Indenter indent = {} ) const override { print(os, indent); }
 };
 
@@ -360 +389 @@
 
         virtual AsmDecl *clone() const override { return new AsmDecl( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual AsmDecl *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
@@ -376 +406 @@
 
         virtual StaticAssertDecl * clone() const override { return new StaticAssertDecl( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual StaticAssertDecl * acceptMutator( Mutator &m )  override { return m.mutate( this ); }
         virtual void print( std::ostream &os, Indenter indent = {} ) const override;

src/SynTree/Expression.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jul 25 14:15:47 2017
-// Update Count     : 54
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Aug 15 13:43:00 2019
+// Update Count     : 64
 //
 
@@ -19 +19 @@
 #include <iostream>                  // for ostream, operator<<, basic_ostream
 #include <list>                      // for list, _List_iterator, list<>::co...
+#include <set>                       // for set
 
 #include "Common/utility.h"          // for maybeClone, cloneAll, deleteAll
@@ -33 +34 @@
 #include "GenPoly/Lvalue.h"
 
-void printInferParams( const InferredParams & inferParams, std::ostream &os, Indenter indent, int level ) {
+void printInferParams( const InferredParams & inferParams, std::ostream & os, Indenter indent, int level ) {
         if ( ! inferParams.empty() ) {
                 os << indent << "with inferred parameters " << level << ":" << std::endl;
                 for ( InferredParams::const_iterator i = inferParams.begin(); i != inferParams.end(); ++i ) {
                         os << indent+1;
-                        Declaration::declFromId( i->second.decl )->printShort( os, indent+1 );
+                        assert(i->second.declptr);
+                        i->second.declptr->printShort( os, indent+1 );
                         os << std::endl;
-                        printInferParams( *i->second.inferParams, os, indent+1, level+1 );
+                        printInferParams( i->second.expr->inferParams, os, indent+1, level+1 );
                 } // for
         } // if
@@ -47 +49 @@
 Expression::Expression() : result( 0 ), env( 0 ) {}
 
-Expression::Expression( const Expression &other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), extension( other.extension ), inferParams( other.inferParams ) {
-}
+Expression::Expression( const Expression & other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), extension( other.extension ), inferParams( other.inferParams ), resnSlots( other.resnSlots ) {}
 
 void Expression::spliceInferParams( Expression * other ) {
@@ -55 +56 @@
                 inferParams[p.first] = std::move( p.second );
         }
+        resnSlots.insert( resnSlots.end(), other->resnSlots.begin(), other->resnSlots.end() );
 }
 
@@ -62 +64 @@
 }
 
-void Expression::print( std::ostream &os, Indenter indent ) const {
+bool Expression::get_lvalue() const {
+        return false;
+}
+
+void Expression::print( std::ostream & os, Indenter indent ) const {
         printInferParams( inferParams, os, indent+1, 0 );
 
@@ -79 +85 @@
 }
 
-ConstantExpr::ConstantExpr( const ConstantExpr &other) : Expression( other ), constant( other.constant ) {
+ConstantExpr::ConstantExpr( const ConstantExpr & other) : Expression( other ), constant( other.constant ) {
 }
 
 ConstantExpr::~ConstantExpr() {}
 
-void ConstantExpr::print( std::ostream &os, Indenter indent ) const {
+void ConstantExpr::print( std::ostream & os, Indenter indent ) const {
         os << "constant expression " ;
         constant.print( os );
@@ -103 +109 @@
 }
 
+VariableExpr::VariableExpr() : Expression(), var( nullptr ) {}
+
 VariableExpr::VariableExpr( DeclarationWithType *_var ) : Expression(), var( _var ) {
         assert( var );
         assert( var->get_type() );
         Type * type = var->get_type()->clone();
-        type->set_lvalue( true );
 
         // xxx - doesn't quite work yet - get different alternatives with the same cost
@@ -117 +124 @@
         //      long long int value;
         //      if ( decl->valueOf( var, value ) ) {
-        //              type->set_lvalue( false );
+        //              type->set_lvalue( false ); // Would have to move to get_lvalue.
         //      }
         // }
@@ -124 +131 @@
 }
 
-VariableExpr::VariableExpr( const VariableExpr &other ) : Expression( other ), var( other.var ) {
+VariableExpr::VariableExpr( const VariableExpr & other ) : Expression( other ), var( other.var ) {
 }
 
 VariableExpr::~VariableExpr() {
         // don't delete the declaration, since it points somewhere else in the tree
+}
+
+bool VariableExpr::get_lvalue() const {
+        // It isn't always an lvalue, but it is never an rvalue.
+        return true;
 }
 
@@ -137 +149 @@
 }
 
-void VariableExpr::print( std::ostream &os, Indenter indent ) const {
+void VariableExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Variable Expression: ";
         var->printShort(os, indent);
@@ -143 +155 @@
 }
 
-SizeofExpr::SizeofExpr( Expression *expr_ ) :
+SizeofExpr::SizeofExpr( Expression * expr_ ) :
                 Expression(), expr(expr_), type(0), isType(false) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
-SizeofExpr::SizeofExpr( Type *type_ ) :
+SizeofExpr::SizeofExpr( Type * type_ ) :
                 Expression(), expr(0), type(type_), isType(true) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
-SizeofExpr::SizeofExpr( const SizeofExpr &other ) :
+SizeofExpr::SizeofExpr( const SizeofExpr & other ) :
         Expression( other ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
 }
@@ -162 +174 @@
 }
 
-void SizeofExpr::print( std::ostream &os, Indenter indent) const {
+void SizeofExpr::print( std::ostream & os, Indenter indent) const {
         os << "Sizeof Expression on: ";
         if (isType) type->print(os, indent+1);
@@ -169 +181 @@
 }
 
-AlignofExpr::AlignofExpr( Expression *expr_ ) :
+AlignofExpr::AlignofExpr( Expression * expr_ ) :
                 Expression(), expr(expr_), type(0), isType(false) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
-AlignofExpr::AlignofExpr( Type *type_ ) :
+AlignofExpr::AlignofExpr( Type * type_ ) :
                 Expression(), expr(0), type(type_), isType(true) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
-AlignofExpr::AlignofExpr( const AlignofExpr &other ) :
+AlignofExpr::AlignofExpr( const AlignofExpr & other ) :
         Expression( other ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
 }
@@ -188 +200 @@
 }
 
-void AlignofExpr::print( std::ostream &os, Indenter indent) const {
+void AlignofExpr::print( std::ostream & os, Indenter indent) const {
         os << "Alignof Expression on: ";
         if (isType) type->print(os, indent+1);
@@ -195 +207 @@
 }
 
-UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type, const std::string &member ) :
+UntypedOffsetofExpr::UntypedOffsetofExpr( Type * type, const std::string & member ) :
                 Expression(), type(type), member(member) {
         assert( type );
@@ -201 +213 @@
 }
 
-UntypedOffsetofExpr::UntypedOffsetofExpr( const UntypedOffsetofExpr &other ) :
+UntypedOffsetofExpr::UntypedOffsetofExpr( const UntypedOffsetofExpr & other ) :
         Expression( other ), type( maybeClone( other.type ) ), member( other.member ) {}
 
@@ -208 +220 @@
 }
 
-void UntypedOffsetofExpr::print( std::ostream &os, Indenter indent) const {
+void UntypedOffsetofExpr::print( std::ostream & os, Indenter indent) const {
         os << "Untyped Offsetof Expression on member " << member << " of ";
         type->print(os, indent+1);
@@ -214 +226 @@
 }
 
-OffsetofExpr::OffsetofExpr( Type *type, DeclarationWithType *member ) :
+OffsetofExpr::OffsetofExpr( Type * type, DeclarationWithType * member ) :
                 Expression(), type(type), member(member) {
         assert( member );
@@ -221 +233 @@
 }
 
-OffsetofExpr::OffsetofExpr( const OffsetofExpr &other ) :
+OffsetofExpr::OffsetofExpr( const OffsetofExpr & other ) :
         Expression( other ), type( maybeClone( other.type ) ), member( other.member ) {}
 
@@ -228 +240 @@
 }
 
-void OffsetofExpr::print( std::ostream &os, Indenter indent) const {
+void OffsetofExpr::print( std::ostream & os, Indenter indent) const {
         os << "Offsetof Expression on member " << member->name << " of ";
         type->print(os, indent+1);
@@ -234 +246 @@
 }
 
-OffsetPackExpr::OffsetPackExpr( StructInstType *type ) : Expression(), type( type ) {
+OffsetPackExpr::OffsetPackExpr( StructInstType * type ) : Expression(), type( type ) {
         assert( type );
         set_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
 }
 
-OffsetPackExpr::OffsetPackExpr( const OffsetPackExpr &other ) : Expression( other ), type( maybeClone( other.type ) ) {}
+OffsetPackExpr::OffsetPackExpr( const OffsetPackExpr & other ) : Expression( other ), type( maybeClone( other.type ) ) {}
 
 OffsetPackExpr::~OffsetPackExpr() { delete type; }
 
-void OffsetPackExpr::print( std::ostream &os, Indenter indent ) const {
+void OffsetPackExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Offset pack expression on ";
         type->print(os, indent+1);
@@ -249 +261 @@
 }
 
-AttrExpr::AttrExpr( Expression *attr, Expression *expr_ ) :
-                Expression(), attr( attr ), expr(expr_), type(0), isType(false) {
-}
-
-AttrExpr::AttrExpr( Expression *attr, Type *type_ ) :
-                Expression(), attr( attr ), expr(0), type(type_), isType(true) {
-}
-
-AttrExpr::AttrExpr( const AttrExpr &other ) :
-                Expression( other ), attr( maybeClone( other.attr ) ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
-}
-
-AttrExpr::~AttrExpr() {
-        delete attr;
-        delete expr;
-        delete type;
-}
-
-void AttrExpr::print( std::ostream &os, Indenter indent) const {
-        os << "Attr ";
-        attr->print( os, indent+1);
-        if ( isType || expr ) {
-                os << "applied to: ";
-                if (isType) type->print(os, indent+1);
-                else expr->print(os, indent+1);
-        } // if
-        Expression::print( os, indent );
-}
-
-CastExpr::CastExpr( Expression *arg, Type *toType, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
+CastExpr::CastExpr( Expression * arg, Type * toType, bool isGenerated ) : arg(arg), isGenerated( isGenerated ) {
         set_result(toType);
 }
 
-CastExpr::CastExpr( Expression *arg, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
+CastExpr::CastExpr( Expression * arg, bool isGenerated ) : arg(arg), isGenerated( isGenerated ) {
         set_result( new VoidType( Type::Qualifiers() ) );
 }
 
-CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
+CastExpr::CastExpr( const CastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
 }
 
@@ -293 +276 @@
 }
 
-void CastExpr::print( std::ostream &os, Indenter indent ) const {
-        os << "Cast of:" << std::endl << indent+1;
+bool CastExpr::get_lvalue() const {
+        // This is actually wrong by C, but it works with our current set-up.
+        return arg->get_lvalue();
+}
+
+void CastExpr::print( std::ostream & os, Indenter indent ) const {
+        os << (isGenerated ? "Generated " : "Explicit ") << "Cast of:" << std::endl << indent+1;
         arg->print(os, indent+1);
         os << std::endl << indent << "... to:";
@@ -306 +294 @@
 }
 
-KeywordCastExpr::KeywordCastExpr( Expression *arg, Target target ) : Expression(), arg(arg), target( target ) {
-}
-
-KeywordCastExpr::KeywordCastExpr( const KeywordCastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), target( other.target ) {
+KeywordCastExpr::KeywordCastExpr( Expression * arg, Target target ) : Expression(), arg(arg), target( target ) {
+}
+
+KeywordCastExpr::KeywordCastExpr( const KeywordCastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ), target( other.target ) {
 }
 
@@ -327 +315 @@
 }
 
-void KeywordCastExpr::print( std::ostream &os, Indenter indent ) const {
+void KeywordCastExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Keyword Cast of:" << std::endl << indent+1;
         arg->print(os, indent+1);
@@ -335 +323 @@
 }
 
-VirtualCastExpr::VirtualCastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
+VirtualCastExpr::VirtualCastExpr( Expression * arg_, Type * toType ) : Expression(), arg(arg_) {
         set_result(toType);
 }
 
-VirtualCastExpr::VirtualCastExpr( const VirtualCastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
+VirtualCastExpr::VirtualCastExpr( const VirtualCastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
 }
 
@@ -346 +334 @@
 }
 
-void VirtualCastExpr::print( std::ostream &os, Indenter indent ) const {
+void VirtualCastExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Virtual Cast of:" << std::endl << indent+1;
         arg->print(os, indent+1);
@@ -359 +347 @@
 }
 
-UntypedMemberExpr::UntypedMemberExpr( Expression * member, Expression *aggregate ) :
+UntypedMemberExpr::UntypedMemberExpr( Expression * member, Expression * aggregate ) :
                 Expression(), member(member), aggregate(aggregate) {
         assert( aggregate );
 }
 
-UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr &other ) :
+UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr & other ) :
                 Expression( other ), member( maybeClone( other.member ) ), aggregate( maybeClone( other.aggregate ) ) {
 }
@@ -373 +361 @@
 }
 
-void UntypedMemberExpr::print( std::ostream &os, Indenter indent ) const {
+bool UntypedMemberExpr::get_lvalue() const {
+        return aggregate->get_lvalue();
+}
+
+void UntypedMemberExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Untyped Member Expression, with field: " << std::endl << indent+1;
         member->print(os, indent+1 );
-        os << indent << "... from aggregate: " << std::endl << indent+1;
+        os << indent << "... from aggregate:" << std::endl << indent+1;
         aggregate->print(os, indent+1);
         Expression::print( os, indent );
 }
 
-MemberExpr::MemberExpr( DeclarationWithType *member, Expression *aggregate ) :
+MemberExpr::MemberExpr( DeclarationWithType * member, Expression * aggregate ) :
                 Expression(), member(member), aggregate(aggregate) {
         assert( member );
@@ -391 +383 @@
         sub.apply( res );
         result = res;
-        result->set_lvalue( true );
         result->get_qualifiers() |= aggregate->result->get_qualifiers();
 }
 
-MemberExpr::MemberExpr( const MemberExpr &other ) :
+MemberExpr::MemberExpr( const MemberExpr & other ) :
                 Expression( other ), member( other.member ), aggregate( maybeClone( other.aggregate ) ) {
 }
@@ -404 +395 @@
 }
 
-void MemberExpr::print( std::ostream &os, Indenter indent ) const {
-        os << "Member Expression, with field: " << std::endl;
+bool MemberExpr::get_lvalue() const {
+        // This is actually wrong by C, but it works with our current set-up.
+        return true;
+}
+
+void MemberExpr::print( std::ostream & os, Indenter indent ) const {
+        os << "Member Expression, with field:" << std::endl;
         os << indent+1;
         member->print( os, indent+1 );
-        os << std::endl << indent << "... from aggregate: " << std::endl << indent+1;
+        os << std::endl << indent << "... from aggregate:" << std::endl << indent+1;
         aggregate->print(os, indent + 1);
         Expression::print( os, indent );
 }
 
-UntypedExpr::UntypedExpr( Expression *function, const std::list<Expression *> &args ) :
+UntypedExpr::UntypedExpr( Expression * function, const std::list<Expression *> & args ) :
                 Expression(), function(function), args(args) {}
 
-UntypedExpr::UntypedExpr( const UntypedExpr &other ) :
+UntypedExpr::UntypedExpr( const UntypedExpr & other ) :
                 Expression( other ), function( maybeClone( other.function ) ) {
         cloneAll( other.args, args );
@@ -435 +431 @@
                         // if references are still allowed in the AST, dereference returns a reference
                         ret->set_result( new ReferenceType( Type::Qualifiers(), ret->get_result() ) );
-                } else {
-                        // references have been removed, in which case dereference returns an lvalue of the base type.
-                        ret->result->set_lvalue( true );
                 }
         }
@@ -454 +447 @@
 }
 
-
-void UntypedExpr::print( std::ostream &os, Indenter indent ) const {
-        os << "Applying untyped: " << std::endl;
+bool UntypedExpr::get_lvalue() const {
+        // from src/GenPoly/Lvalue.cc: isIntrinsicReference
+        static std::set<std::string> lvalueFunctions = { "*?", "?[?]" };
+        std::string fname = InitTweak::getFunctionName( const_cast< UntypedExpr * >( this ) );
+        return lvalueFunctions.count(fname);
+}
+
+void UntypedExpr::print( std::ostream & os, Indenter indent ) const {
+        os << "Applying untyped:" << std::endl;
         os << indent+1;
         function->print(os, indent+1);
-        os << std::endl << indent << "...to: " << std::endl;
+        os << std::endl << indent << "...to:" << std::endl;
         printAll(args, os, indent+1);
         Expression::print( os, indent );
@@ -469 +468 @@
 }
 
-NameExpr::NameExpr( const NameExpr &other ) : Expression( other ), name( other.name ) {
+NameExpr::NameExpr( const NameExpr & other ) : Expression( other ), name( other.name ) {
 }
 
 NameExpr::~NameExpr() {}
 
-void NameExpr::print( std::ostream &os, Indenter indent ) const {
+void NameExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Name: " << get_name();
         Expression::print( os, indent );
 }
 
-LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp ) :
+LogicalExpr::LogicalExpr( Expression * arg1_, Expression * arg2_, bool andp ) :
                 Expression(), arg1(arg1_), arg2(arg2_), isAnd(andp) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
 }
 
-LogicalExpr::LogicalExpr( const LogicalExpr &other ) :
+LogicalExpr::LogicalExpr( const LogicalExpr & other ) :
                 Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ), isAnd( other.isAnd ) {
 }
@@ -493 +492 @@
 }
 
-void LogicalExpr::print( std::ostream &os, Indenter indent )const {
+void LogicalExpr::print( std::ostream & os, Indenter indent )const {
         os << "Short-circuited operation (" << (isAnd ? "and" : "or") << ") on: ";
         arg1->print(os);
@@ -504 +503 @@
                 Expression(), arg1(arg1), arg2(arg2), arg3(arg3) {}
 
-ConditionalExpr::ConditionalExpr( const ConditionalExpr &other ) :
+ConditionalExpr::ConditionalExpr( const ConditionalExpr & other ) :
                 Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ), arg3( maybeClone( other.arg3 ) ) {
 }
@@ -514 +513 @@
 }
 
-void ConditionalExpr::print( std::ostream &os, Indenter indent ) const {
+bool ConditionalExpr::get_lvalue() const {
+        return false;
+}
+
+void ConditionalExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Conditional expression on: " << std::endl << indent+1;
         arg1->print( os, indent+1 );
@@ -527 +530 @@
 
 
-void AsmExpr::print( std::ostream &os, Indenter indent ) const {
+void AsmExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Asm Expression: " << std::endl;
         if ( inout ) inout->print( os, indent+1 );
@@ -538 +541 @@
         assert( callExpr );
         assert( callExpr->result );
-        set_result( callExpr->get_result()->clone() );
+        set_result( callExpr->result->clone() );
 }
 
 ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other ) : Expression( other ), callExpr( maybeClone( other.callExpr ) ) {
-        cloneAll( other.tempDecls, tempDecls );
-        cloneAll( other.returnDecls, returnDecls );
-        cloneAll( other.dtors, dtors );
 }
 
@@ -550 +550 @@
         set_env( nullptr ); // ImplicitCopyCtorExpr does not take ownership of an environment
         delete callExpr;
-        deleteAll( tempDecls );
-        deleteAll( returnDecls );
-        deleteAll( dtors );
-}
-
-void ImplicitCopyCtorExpr::print( std::ostream &os, Indenter indent ) const {
+}
+
+void ImplicitCopyCtorExpr::print( std::ostream & os, Indenter indent ) const {
         os <<  "Implicit Copy Constructor Expression: " << std::endl << indent+1;
         callExpr->print( os, indent+1 );
-        os << std::endl << indent << "... with temporaries:" << std::endl;
-        printAll( tempDecls, os, indent+1 );
-        os << std::endl << indent << "... with return temporaries:" << std::endl;
-        printAll( returnDecls, os, indent+1 );
-        Expression::print( os, indent );
 }
 
@@ -581 +573 @@
 }
 
-void ConstructorExpr::print( std::ostream &os, Indenter indent ) const {
+bool ConstructorExpr::get_lvalue() const {
+        return false;
+}
+
+void ConstructorExpr::print( std::ostream & os, Indenter indent ) const {
         os <<  "Constructor Expression: " << std::endl << indent+1;
         callExpr->print( os, indent + 2 );
@@ -590 +586 @@
 CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : initializer( initializer ) {
         assert( type && initializer );
-        type->set_lvalue( true );
         set_result( type );
 }
 
-CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), initializer( other.initializer->clone() ) {}
+CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr & other ) : Expression( other ), initializer( other.initializer->clone() ) {}
 
 CompoundLiteralExpr::~CompoundLiteralExpr() {
@@ -600 +595 @@
 }
 
-void CompoundLiteralExpr::print( std::ostream &os, Indenter indent ) const {
+bool CompoundLiteralExpr::get_lvalue() const {
+        return true;
+}
+
+void CompoundLiteralExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Compound Literal Expression: " << std::endl << indent+1;
         result->print( os, indent+1 );
@@ -608 +607 @@
 }
 
-RangeExpr::RangeExpr( Expression *low, Expression *high ) : low( low ), high( high ) {}
-RangeExpr::RangeExpr( const RangeExpr &other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
-void RangeExpr::print( std::ostream &os, Indenter indent ) const {
+RangeExpr::RangeExpr( Expression * low, Expression * high ) : low( low ), high( high ) {}
+RangeExpr::RangeExpr( const RangeExpr & other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
+void RangeExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Range Expression: ";
         low->print( os, indent );
@@ -618 +617 @@
 }
 
-StmtExpr::StmtExpr( CompoundStmt *statements ) : statements( statements ) {
+StmtExpr::StmtExpr( CompoundStmt * statements ) : statements( statements ) {
         computeResult();
 }
-StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) {
+StmtExpr::StmtExpr( const StmtExpr & other ) : Expression( other ), statements( other.statements->clone() ), resultExpr( other.resultExpr ) {
         cloneAll( other.returnDecls, returnDecls );
         cloneAll( other.dtors, dtors );
@@ -650 +649 @@
         }
 }
-void StmtExpr::print( std::ostream &os, Indenter indent ) const {
+bool StmtExpr::get_lvalue() const {
+        return false;
+}
+void StmtExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Statement Expression: " << std::endl << indent+1;
         statements->print( os, indent+1 );
@@ -666 +668 @@
 
 long long UniqueExpr::count = 0;
-UniqueExpr::UniqueExpr( Expression *expr, long long idVal ) : expr( expr ), object( nullptr ), var( nullptr ), id( idVal ) {
+UniqueExpr::UniqueExpr( Expression * expr, long long idVal ) : expr( expr ), object( nullptr ), var( nullptr ), id( idVal ) {
         assert( expr );
         assert( count != -1 );
@@ -674 +676 @@
         }
 }
-UniqueExpr::UniqueExpr( const UniqueExpr &other ) : Expression( other ), expr( maybeClone( other.expr ) ), object( maybeClone( other.object ) ), var( maybeClone( other.var ) ), id( other.id ) {
+UniqueExpr::UniqueExpr( const UniqueExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), object( maybeClone( other.object ) ), var( maybeClone( other.var ) ), id( other.id ) {
 }
 UniqueExpr::~UniqueExpr() {
@@ -681 +683 @@
         delete var;
 }
-void UniqueExpr::print( std::ostream &os, Indenter indent ) const {
+void UniqueExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Unique Expression with id:" << id << std::endl << indent+1;
         expr->print( os, indent+1 );
@@ -732 +734 @@
 }
 
-DeletedExpr::DeletedExpr( Expression * expr, BaseSyntaxNode * deleteStmt ) : expr( expr ), deleteStmt( deleteStmt ) {
+DeletedExpr::DeletedExpr( Expression * expr, Declaration * deleteStmt ) : expr( expr ), deleteStmt( deleteStmt ) {
         assert( expr->result );
         result = expr->result->clone();
@@ -746 +748 @@
         os << std::endl << indent+1 << "... deleted by: ";
         deleteStmt->print( os, indent+1 );
+}
+
+
+DefaultArgExpr::DefaultArgExpr( Expression * expr ) : expr( expr ) {
+        assert( expr->result );
+        result = expr->result->clone();
+}
+DefaultArgExpr::DefaultArgExpr( const DefaultArgExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ) {}
+DefaultArgExpr::~DefaultArgExpr() {
+        delete expr;
+}
+
+void DefaultArgExpr::print( std::ostream & os, Indenter indent ) const {
+        os << "Default Argument Expression" << std::endl << indent+1;
+        expr->print( os, indent+1 );
 }
 

src/SynTree/Expression.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Sep  3 19:23:46 2017
-// Update Count     : 48
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Aug 15 13:46:00 2019
+// Update Count     : 54
 //
 
@@ -21 +21 @@
 #include <memory>                 // for allocator, unique_ptr
 #include <string>                 // for string
+#include <vector>                 // for vector
 
 #include "BaseSyntaxNode.h"       // for BaseSyntaxNode
@@ -38 +39 @@
 /// but subject to decay-to-pointer and type parameter renaming
 struct ParamEntry {
-        ParamEntry(): decl( 0 ), actualType( 0 ), formalType( 0 ), expr( 0 ), inferParams( new InferredParams ) {}
-        ParamEntry( UniqueId decl, Type * actualType, Type * formalType, Expression* expr ): decl( decl ), actualType( actualType ), formalType( formalType ), expr( expr ), inferParams( new InferredParams ) {}
+        ParamEntry(): decl( 0 ), declptr( nullptr ), actualType( nullptr ), formalType( nullptr ), expr( nullptr ) {}
+        ParamEntry( UniqueId decl, Declaration * declptr, Type * actualType, Type * formalType, Expression* expr );
         ParamEntry( const ParamEntry & other );
         ParamEntry( ParamEntry && other );
         ~ParamEntry();
-        ParamEntry & operator=( const ParamEntry & other );
         ParamEntry & operator=( ParamEntry && other );
 
-        UniqueId decl;
-        Type * actualType;
-        Type * formalType;
+        UniqueId const decl;
+        Declaration * const declptr;
+        Type * const actualType;
+        Type * const formalType;
         Expression * expr;
-        std::unique_ptr< InferredParams > inferParams;
 };
 
@@ -59 +59 @@
         TypeSubstitution * env;
         bool extension = false;
-        InferredParams inferParams;
+        InferredParams inferParams;       ///< Post-resolution inferred parameter slots
+        std::vector<UniqueId> resnSlots;  ///< Pre-resolution inferred parameter slots
+
+        // xxx - should turn inferParams+resnSlots into a union to save some memory
 
         Expression();
@@ -68 +71 @@
         const Type * get_result() const { return result; }
         void set_result( Type * newValue ) { result = newValue; }
+        virtual bool get_lvalue() const;
 
         TypeSubstitution * get_env() const { return env; }
@@ -74 +78 @@
         Expression * set_extension( bool exten ) { extension = exten; return this; }
 
-        InferredParams & get_inferParams() { return inferParams; }
-
         // move other's inferParams to this
         void spliceInferParams( Expression * other );
@@ -81 +83 @@
         virtual Expression * clone() const override = 0;
         virtual void accept( Visitor & v ) override = 0;
+        virtual void accept( Visitor & v ) const override = 0;
         virtual Expression * acceptMutator( Mutator & m ) override = 0;
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
@@ -96 +99 @@
         virtual ~ApplicationExpr();
 
+        bool get_lvalue() const final;
+
         Expression * get_function() const { return function; }
         void set_function( Expression * newValue ) { function = newValue; }
         std::list<Expression *>& get_args() { return args; }
 
-        virtual ApplicationExpr * clone() const { return new ApplicationExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual ApplicationExpr * clone() const override { return new ApplicationExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -118 +124 @@
         virtual ~UntypedExpr();
 
+        bool get_lvalue() const final;
+
         Expression * get_function() const { return function; }
         void set_function( Expression * newValue ) { function = newValue; }
@@ -128 +136 @@
         static UntypedExpr * createAssign( Expression * arg1, Expression * arg2 );
 
-        virtual UntypedExpr * clone() const { return new UntypedExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual UntypedExpr * clone() const override { return new UntypedExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -146 +155 @@
         void set_name( std::string newValue ) { name = newValue; }
 
-        virtual NameExpr * clone() const { return new NameExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual NameExpr * clone() const override { return new NameExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -167 +177 @@
         void set_arg(Expression * newValue ) { arg = newValue; }
 
-        virtual AddressExpr * clone() const { return new AddressExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual AddressExpr * clone() const override { return new AddressExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -183 +194 @@
         virtual ~LabelAddressExpr();
 
-        virtual LabelAddressExpr * clone() const { return new LabelAddressExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual LabelAddressExpr * clone() const override { return new LabelAddressExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -193 +205 @@
   public:
         Expression * arg;
-        bool isGenerated = true; // whether this cast appeared in the source program
+        bool isGenerated = true; // cast generated implicitly by code generation or explicit in program
 
         CastExpr( Expression * arg, bool isGenerated = true );
@@ -201 +213 @@
         virtual ~CastExpr();
 
+        bool get_lvalue() const final;
+
         Expression * get_arg() const { return arg; }
         void set_arg( Expression * newValue ) { arg = newValue; }
 
-        virtual CastExpr * clone() const { return new CastExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual CastExpr * clone() const override { return new CastExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -224 +239 @@
         const std::string & targetString() const;
 
-        virtual KeywordCastExpr * clone() const { return new KeywordCastExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual KeywordCastExpr * clone() const override { return new KeywordCastExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -242 +258 @@
         void set_arg( Expression * newValue ) { arg = newValue; }
 
-        virtual VirtualCastExpr * clone() const { return new VirtualCastExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual VirtualCastExpr * clone() const override { return new VirtualCastExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -257 +274 @@
         UntypedMemberExpr( const UntypedMemberExpr & other );
         virtual ~UntypedMemberExpr();
+
+        bool get_lvalue() const final;
 
         Expression * get_member() const { return member; }
@@ -263 +282 @@
         void set_aggregate( Expression * newValue ) { aggregate = newValue; }
 
-        virtual UntypedMemberExpr * clone() const { return new UntypedMemberExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual UntypedMemberExpr * clone() const override { return new UntypedMemberExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -279 +299 @@
         MemberExpr( const MemberExpr & other );
         virtual ~MemberExpr();
+
+        bool get_lvalue() const final;
 
         DeclarationWithType * get_member() const { return member; }
@@ -285 +307 @@
         void set_aggregate( Expression * newValue ) { aggregate = newValue; }
 
-        virtual MemberExpr * clone() const { return new MemberExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual MemberExpr * clone() const override { return new MemberExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -297 +320 @@
         DeclarationWithType * var;
 
+        VariableExpr();
         VariableExpr( DeclarationWithType * var );
         VariableExpr( const VariableExpr & other );
         virtual ~VariableExpr();
 
+        bool get_lvalue() const final;
+
         DeclarationWithType * get_var() const { return var; }
         void set_var( DeclarationWithType * newValue ) { var = newValue; }
@@ -306 +332 @@
         static VariableExpr * functionPointer( FunctionDecl * decl );
 
-        virtual VariableExpr * clone() const { return new VariableExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual VariableExpr * clone() const override { return new VariableExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -327 +354 @@
         long long int intValue() const;
 
-        virtual ConstantExpr * clone() const { return new ConstantExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual ConstantExpr * clone() const override { return new ConstantExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -352 +380 @@
         void set_isType( bool newValue ) { isType = newValue; }
 
-        virtual SizeofExpr * clone() const { return new SizeofExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual SizeofExpr * clone() const override { return new SizeofExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -377 +406 @@
         void set_isType( bool newValue ) { isType = newValue; }
 
-        virtual AlignofExpr * clone() const { return new AlignofExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual AlignofExpr * clone() const override { return new AlignofExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -398 +428 @@
         void set_type( Type * newValue ) { type = newValue; }
 
-        virtual UntypedOffsetofExpr * clone() const { return new UntypedOffsetofExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual UntypedOffsetofExpr * clone() const override { return new UntypedOffsetofExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -419 +450 @@
         void set_member( DeclarationWithType * newValue ) { member = newValue; }
 
-        virtual OffsetofExpr * clone() const { return new OffsetofExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual OffsetofExpr * clone() const override { return new OffsetofExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -437 +469 @@
         void set_type( StructInstType * newValue ) { type = newValue; }
 
-        virtual OffsetPackExpr * clone() const { return new OffsetPackExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
-};
-
-/// AttrExpr represents an @attribute expression (like sizeof, but user-defined)
-class AttrExpr : public Expression {
-  public:
-        Expression * attr;
-        Expression * expr;
-        Type * type;
-        bool isType;
-
-        AttrExpr(Expression * attr, Expression * expr );
-        AttrExpr( const AttrExpr & other );
-        AttrExpr( Expression * attr, Type * type );
-        virtual ~AttrExpr();
-
-        Expression * get_attr() const { return attr; }
-        void set_attr( Expression * newValue ) { attr = newValue; }
-        Expression * get_expr() const { return expr; }
-        void set_expr( Expression * newValue ) { expr = newValue; }
-        Type * get_type() const { return type; }
-        void set_type( Type * newValue ) { type = newValue; }
-        bool get_isType() const { return isType; }
-        void set_isType( bool newValue ) { isType = newValue; }
-
-        virtual AttrExpr * clone() const { return new AttrExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual OffsetPackExpr * clone() const override { return new OffsetPackExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -487 +492 @@
         void set_arg2( Expression * newValue ) { arg2 = newValue; }
 
-        virtual LogicalExpr * clone() const { return new LogicalExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual LogicalExpr * clone() const override { return new LogicalExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 
   private:
@@ -506 +512 @@
         ConditionalExpr( const ConditionalExpr & other );
         virtual ~ConditionalExpr();
+
+        bool get_lvalue() const final;
 
         Expression * get_arg1() const { return arg1; }
@@ -514 +522 @@
         void set_arg3( Expression * newValue ) { arg3 = newValue; }
 
-        virtual ConditionalExpr * clone() const { return new ConditionalExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual ConditionalExpr * clone() const override { return new ConditionalExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -529 +538 @@
         CommaExpr( const CommaExpr & other );
         virtual ~CommaExpr();
+
+        bool get_lvalue() const final;
 
         Expression * get_arg1() const { return arg1; }
@@ -535 +546 @@
         void set_arg2( Expression * newValue ) { arg2 = newValue; }
 
-        virtual CommaExpr * clone() const { return new CommaExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual CommaExpr * clone() const override { return new CommaExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -553 +565 @@
         void set_type( Type * newValue ) { type = newValue; }
 
-        virtual TypeExpr * clone() const { return new TypeExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual TypeExpr * clone() const override { return new TypeExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -579 +592 @@
         void set_operand( Expression * newValue ) { operand = newValue; }
 
-        virtual AsmExpr * clone() const { return new AsmExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual AsmExpr * clone() const override { return new AsmExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 
         // https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints
@@ -591 +605 @@
 class ImplicitCopyCtorExpr : public Expression {
 public:
-        ApplicationExpr * callExpr;
-        std::list< ObjectDecl * > tempDecls;
-        std::list< ObjectDecl * > returnDecls;
-        std::list< Expression * > dtors;
+        ApplicationExpr * callExpr = nullptr;
 
         ImplicitCopyCtorExpr( ApplicationExpr * callExpr );
@@ -600 +611 @@
         virtual ~ImplicitCopyCtorExpr();
 
-        ApplicationExpr * get_callExpr() const { return callExpr; }
-        void set_callExpr( ApplicationExpr * newValue ) { callExpr = newValue; }
-
-        std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
-        std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
-        std::list< Expression * > & get_dtors() { return dtors; }
-
-        virtual ImplicitCopyCtorExpr * clone() const { return new ImplicitCopyCtorExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual ImplicitCopyCtorExpr * clone() const override { return new ImplicitCopyCtorExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -622 +627 @@
         ~ConstructorExpr();
 
+        bool get_lvalue() const final;
+
         Expression * get_callExpr() const { return callExpr; }
         void set_callExpr( Expression * newValue ) { callExpr = newValue; }
 
-        virtual ConstructorExpr * clone() const { return new ConstructorExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual ConstructorExpr * clone() const override { return new ConstructorExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -640 +648 @@
         virtual ~CompoundLiteralExpr();
 
+        bool get_lvalue() const final;
+
         Initializer * get_initializer() const { return initializer; }
         void set_initializer( Initializer * i ) { initializer = i; }
 
-        virtual CompoundLiteralExpr * clone() const { return new CompoundLiteralExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual CompoundLiteralExpr * clone() const override { return new CompoundLiteralExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -662 +673 @@
         RangeExpr * set_high( Expression * high ) { RangeExpr::high = high; return this; }
 
-        virtual RangeExpr * clone() const { return new RangeExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual RangeExpr * clone() const override { return new RangeExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -679 +691 @@
         std::list<Expression*>& get_exprs() { return exprs; }
 
-        virtual UntypedTupleExpr * clone() const { return new UntypedTupleExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual UntypedTupleExpr * clone() const override { return new UntypedTupleExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -694 +707 @@
         virtual ~TupleExpr();
 
+        bool get_lvalue() const final;
+
         std::list<Expression*>& get_exprs() { return exprs; }
 
-        virtual TupleExpr * clone() const { return new TupleExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual TupleExpr * clone() const override { return new TupleExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -711 +727 @@
         TupleIndexExpr( const TupleIndexExpr & other );
         virtual ~TupleIndexExpr();
+
+        bool get_lvalue() const final;
 
         Expression * get_tuple() const { return tuple; }
@@ -717 +735 @@
         TupleIndexExpr * set_index( unsigned int newValue ) { index = newValue; return this; }
 
-        virtual TupleIndexExpr * clone() const { return new TupleIndexExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual TupleIndexExpr * clone() const override { return new TupleIndexExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -735 +754 @@
         StmtExpr * get_stmtExpr() const { return stmtExpr; }
 
-        virtual TupleAssignExpr * clone() const { return new TupleAssignExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual TupleAssignExpr * clone() const override { return new TupleAssignExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+
+        friend class ConverterNewToOld;
+  private:
+    TupleAssignExpr( StmtExpr * stmts );
 };
 
@@ -748 +772 @@
         std::list< Expression * > dtors; // destructor(s) for return variable(s)
 
+        // readonly
+        ExprStmt * resultExpr = nullptr;
+
         StmtExpr( CompoundStmt * statements );
         StmtExpr( const StmtExpr & other );
         virtual ~StmtExpr();
 
+        bool get_lvalue() const final;
+
         CompoundStmt * get_statements() const { return statements; }
         StmtExpr * set_statements( CompoundStmt * newValue ) { statements = newValue; return this; }
@@ -761 +790 @@
         std::list< Expression * > & get_dtors() { return dtors; }
 
-        virtual StmtExpr * clone() const { return new StmtExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual StmtExpr * clone() const override { return new StmtExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -788 +818 @@
         int get_id() const { return id; }
 
-        virtual UniqueExpr * clone() const { return new UniqueExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual UniqueExpr * clone() const override { return new UniqueExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 
 private:
@@ -822 +853 @@
         std::list<InitAlternative> & get_initAlts() { return initAlts; }
 
-        virtual UntypedInitExpr * clone() const { return new UntypedInitExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual UntypedInitExpr * clone() const override { return new UntypedInitExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -843 +875 @@
         InitExpr * set_designation( Designation * newValue ) { designation = newValue; return this; }
 
-        virtual InitExpr * clone() const { return new InitExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual InitExpr * clone() const override { return new InitExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -853 +886 @@
 public:
         Expression * expr;
-        BaseSyntaxNode * deleteStmt;
-
-        DeletedExpr( Expression * expr, BaseSyntaxNode * deleteStmt );
+        Declaration * deleteStmt;
+
+        DeletedExpr( Expression * expr, Declaration * deleteStmt );
         DeletedExpr( const DeletedExpr & other );
         ~DeletedExpr();
 
-        virtual DeletedExpr * clone() const { return new DeletedExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual DeletedExpr * clone() const override { return new DeletedExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
+
+/// expression wrapping the use of a default argument - should never make it past the resolver.
+class DefaultArgExpr : public Expression {
+public:
+        Expression * expr;
+
+        DefaultArgExpr( Expression * expr );
+        DefaultArgExpr( const DefaultArgExpr & other );
+        ~DefaultArgExpr();
+
+        virtual DefaultArgExpr * clone() const override { return new DefaultArgExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -887 +937 @@
         virtual ~GenericExpr();
 
-        virtual GenericExpr * clone() const { return new GenericExpr( * this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual GenericExpr * clone() const override { return new GenericExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 

src/SynTree/FunctionDecl.cc

@@ -87 +87 @@
 
         if ( statements ) {
-                os << indent << "... with body " << endl << indent+1;
+                os << indent << "... with body" << endl << indent+1;
                 statements->print( os, indent+1 );
         } // if

src/SynTree/FunctionType.cc

@@ -66 +66 @@
                 os << indent+1 << "accepting unspecified arguments" << endl;
         } // if
-        os << indent << "... returning ";
+        os << indent << "... returning";
         if ( returnVals.empty() ) {
-                os << "nothing " << endl;
+                os << " nothing" << endl;
         } else {
                 os << endl;

src/SynTree/Initializer.h

@@ -38 +38 @@
 
         virtual Designation * clone() const override { return new Designation( *this ); };
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Designation * acceptMutator( Mutator &m ) override { return m.mutate( this ); }
         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
@@ -52 +53 @@
         virtual ~Initializer();
 
-        bool get_maybeConstructed() { return maybeConstructed; }
+        bool get_maybeConstructed() const { return maybeConstructed; }
 
         virtual Initializer *clone() const override = 0;
-        virtual void accept( Visitor &v ) override = 0;
+        virtual void accept( Visitor & v ) override = 0;
+        virtual void accept( Visitor & v ) const override = 0;
         virtual Initializer *acceptMutator( Mutator &m ) override = 0;
         virtual void print( std::ostream &os, Indenter indent = {} ) const override = 0;
@@ -76 +78 @@
 
         virtual SingleInit *clone() const override { return new SingleInit( *this); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
@@ -104 +107 @@
 
         virtual ListInit *clone() const override { return new ListInit( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
@@ -133 +137 @@
 
         ConstructorInit *clone() const override { return new ConstructorInit( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
         virtual void print( std::ostream &os, Indenter indent = {} ) const override;

src/SynTree/Label.h

@@ -35 +35 @@
         operator std::string() const { return name; }
         bool empty() { return name.empty(); }
-  private:
+
         std::string name;
         Statement * labelled;

src/SynTree/Mutator.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Jul 24 16:31:00 2017
-// Update Count     : 16
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Jul 25 22:37:46 2019
+// Update Count     : 17
 //
 #pragma once
@@ -52 +52 @@
         virtual Statement * mutate( FinallyStmt * catchStmt ) = 0;
         virtual Statement * mutate( WaitForStmt * waitforStmt ) = 0;
-        virtual Statement * mutate( WithStmt * withStmt ) = 0;
+        virtual Declaration * mutate( WithStmt * withStmt ) = 0;
         virtual NullStmt * mutate( NullStmt * nullStmt ) = 0;
         virtual Statement * mutate( DeclStmt * declStmt ) = 0;
@@ -74 +74 @@
         virtual Expression * mutate( OffsetofExpr * offsetofExpr ) = 0;
         virtual Expression * mutate( OffsetPackExpr * offsetPackExpr ) = 0;
-        virtual Expression * mutate( AttrExpr * attrExpr ) = 0;
         virtual Expression * mutate( LogicalExpr * logicalExpr ) = 0;
         virtual Expression * mutate( ConditionalExpr * conditionalExpr ) = 0;
@@ -93 +92 @@
         virtual Expression * mutate( InitExpr  * initExpr ) = 0;
         virtual Expression * mutate( DeletedExpr * delExpr ) = 0;
+        virtual Expression * mutate( DefaultArgExpr * argExpr ) = 0;
         virtual Expression * mutate( GenericExpr * genExpr ) = 0;
 
@@ -100 +100 @@
         virtual Type * mutate( ArrayType * arrayType ) = 0;
         virtual Type * mutate( ReferenceType * refType ) = 0;
+        virtual Type * mutate( QualifiedType * qualType ) = 0;
         virtual Type * mutate( FunctionType * functionType ) = 0;
         virtual Type * mutate( StructInstType * aggregateUseType ) = 0;
@@ -112 +113 @@
         virtual Type * mutate( ZeroType * zeroType ) = 0;
         virtual Type * mutate( OneType * oneType ) = 0;
+        virtual Type * mutate( GlobalScopeType * globalType ) = 0;
 
         virtual Designation * mutate( Designation * designation ) = 0 ;
@@ -117 +119 @@
         virtual Initializer * mutate( ListInit * listInit ) = 0 ;
         virtual Initializer * mutate( ConstructorInit * ctorInit ) = 0 ;
-
-        virtual Subrange * mutate( Subrange * subrange ) = 0;
 
         virtual Constant * mutate( Constant * constant ) = 0;

src/SynTree/ObjectDecl.cc

@@ -66 +66 @@
 
         if ( ! attributes.empty() ) {
-                os << std::endl << indent << "... with attributes: " << std::endl;
+                os << std::endl << indent << "... with attributes:" << std::endl;
                 printAll( attributes, os, indent+1 );
         }

src/SynTree/ReferenceToType.cc

@@ -76 +76 @@
 bool StructInstType::isComplete() const { return baseStruct ? baseStruct->has_body() : false; }
 
-AggregateDecl * StructInstType::getAggr() { return baseStruct; }
+AggregateDecl * StructInstType::getAggr() const { return baseStruct; }
 
 TypeSubstitution StructInstType::genericSubstitution() const {
@@ -93 +93 @@
         else {
                 Type::print( os, indent );
-                os << "instance of " << typeString() << " " << name << " with body " << baseStruct->has_body() << " ";
+                os << "instance of " << typeString() << " " << name << " with body " << baseStruct->has_body();
                 if ( ! parameters.empty() ) {
                         os << endl << indent << "... with parameters" << endl;
@@ -119 +119 @@
 bool UnionInstType::isComplete() const { return baseUnion ? baseUnion->has_body() : false; }
 
-AggregateDecl * UnionInstType::getAggr() { return baseUnion; }
+AggregateDecl * UnionInstType::getAggr() const { return baseUnion; }
 
 TypeSubstitution UnionInstType::genericSubstitution() const {
@@ -136 +136 @@
         else {
                 Type::print( os, indent );
-                os << "instance of " << typeString() << " " << name << " with body " << baseUnion->has_body() << " ";
+                os << "instance of " << typeString() << " " << name << " with body " << baseUnion->has_body();
                 if ( ! parameters.empty() ) {
                         os << endl << indent << "... with parameters" << endl;
@@ -152 +152 @@
 bool EnumInstType::isComplete() const { return baseEnum ? baseEnum->has_body() : false; }
 
+AggregateDecl * EnumInstType::getAggr() const { return baseEnum; }
+
 void EnumInstType::print( std::ostream &os, Indenter indent ) const {
         using std::endl;
@@ -158 +160 @@
         else {
                 Type::print( os, indent );
-                os << "instance of " << typeString() << " " << name << " with body " << baseEnum->has_body() << " ";
+                os << "instance of " << typeString() << " " << name << " with body " << baseEnum->has_body();
         } // if
 }
@@ -203 +205 @@
 
         Type::print( os, indent );
-        os << "instance of " << typeString() << " " << get_name() << " (" << ( isFtype ? "" : "not" ) << " function type) ";
+        os << "instance of " << typeString() << " " << get_name() << " (" << ( isFtype ? "" : "not" ) << " function type)";
         if ( ! parameters.empty() ) {
                 os << endl << indent << "... with parameters" << endl;

src/SynTree/Statement.cc

@@ -493 +493 @@
 
 
-WithStmt::WithStmt( const std::list< Expression * > & exprs, Statement * stmt ) : Statement(), exprs( exprs ), stmt( stmt ) {}
-WithStmt::WithStmt( const WithStmt & other ) : Statement( other ), stmt( maybeClone( other.stmt ) ) {
+WithStmt::WithStmt( const std::list< Expression * > & exprs, Statement * stmt ) : Declaration("", noStorageClasses, LinkageSpec::Cforall), exprs( exprs ), stmt( stmt ) {}
+WithStmt::WithStmt( const WithStmt & other ) : Declaration( other ), stmt( maybeClone( other.stmt ) ) {
         cloneAll( other.exprs, exprs );
 }

src/SynTree/Statement.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar  8 14:53:02 2018
-// Update Count     : 78
+// Last Modified On : Tue Mar 12 09:01:53 2019
+// Update Count     : 83
 //
 
@@ -19 +19 @@
 #include <list>                    // for list
 #include <memory>                  // for allocator
-#include <vector>                        // for vector
+#include <vector>                                  // for vector
 
 #include "BaseSyntaxNode.h"        // for BaseSyntaxNode
@@ -43 +43 @@
         const std::list<Label> & get_labels() const { return labels; }
 
-        virtual Statement *clone() const override = 0;
-        virtual void accept( Visitor &v ) override = 0;
-        virtual Statement *acceptMutator( Mutator &m ) override = 0;
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual Statement * clone() const override = 0;
+        virtual void accept( Visitor & v ) override = 0;
+        virtual void accept( Visitor & v ) const override = 0;
+        virtual Statement * acceptMutator( Mutator & m ) override = 0;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -55 +56 @@
         CompoundStmt();
         CompoundStmt( std::list<Statement *> stmts );
-        CompoundStmt( const CompoundStmt &other );
+        CompoundStmt( const CompoundStmt & other );
         virtual ~CompoundStmt();
 
@@ -62 +63 @@
         void push_front( Statement * stmt ) { kids.push_front( stmt ); }
 
-        virtual CompoundStmt *clone() const override { return new CompoundStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual CompoundStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual CompoundStmt * clone() const override { return new CompoundStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual CompoundStmt * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -72 +74 @@
         NullStmt( const std::list<Label> & labels = {} );
 
-        virtual NullStmt *clone() const override { return new NullStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual NullStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual NullStmt * clone() const override { return new NullStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual NullStmt * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
 class ExprStmt : public Statement {
   public:
-        Expression *expr;
-
-        ExprStmt( Expression *expr );
-        ExprStmt( const ExprStmt &other );
+        Expression * expr;
+
+        ExprStmt( Expression * expr );
+        ExprStmt( const ExprStmt & other );
         virtual ~ExprStmt();
 
-        Expression *get_expr() { return expr; }
-        void set_expr( Expression *newValue ) { expr = newValue; }
-
-        virtual ExprStmt *clone() const override { return new ExprStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        Expression * get_expr() { return expr; }
+        void set_expr( Expression * newValue ) { expr = newValue; }
+
+        virtual ExprStmt * clone() const override { return new ExprStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -98 +102 @@
   public:
         bool voltile;
-        Expression *instruction;
+        Expression * instruction;
         std::list<Expression *> output, input;
         std::list<ConstantExpr *> clobber;
         std::list<Label> gotolabels;
 
-        AsmStmt( bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
-        AsmStmt( const AsmStmt &other );
+        AsmStmt( bool voltile, Expression * instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
+        AsmStmt( const AsmStmt & other );
         virtual ~AsmStmt();
 
@@ -114 +118 @@
         void set_output( const std::list<Expression *> & newValue ) { output = newValue; }
         std::list<Expression *> & get_input() { return input; }
-        void set_input( const std::list<Expression *> &newValue ) { input = newValue; }
+        void set_input( const std::list<Expression *> & newValue ) { input = newValue; }
         std::list<ConstantExpr *> & get_clobber() { return clobber; }
-        void set_clobber( const std::list<ConstantExpr *> &newValue ) { clobber = newValue; }
+        void set_clobber( const std::list<ConstantExpr *> & newValue ) { clobber = newValue; }
         std::list<Label> & get_gotolabels() { return gotolabels; }
-        void set_gotolabels( const std::list<Label> &newValue ) { gotolabels = newValue; }
-
-        virtual AsmStmt * clone() const { return new AsmStmt( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Statement * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        void set_gotolabels( const std::list<Label> & newValue ) { gotolabels = newValue; }
+
+        virtual AsmStmt * clone() const override { return new AsmStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -133 +138 @@
         virtual ~DirectiveStmt(){}
 
-        virtual DirectiveStmt * clone() const { return new DirectiveStmt( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Statement * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+        virtual DirectiveStmt * clone() const override { return new DirectiveStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
 class IfStmt : public Statement {
   public:
-        Expression *condition;
-        Statement *thenPart;
-        Statement *elsePart;
+        Expression * condition;
+        Statement * thenPart;
+        Statement * elsePart;
         std::list<Statement *> initialization;
 
-        IfStmt( Expression *condition, Statement *thenPart, Statement *elsePart,
+        IfStmt( Expression * condition, Statement * thenPart, Statement * elsePart,
                         std::list<Statement *> initialization = std::list<Statement *>() );
-        IfStmt( const IfStmt &other );
+        IfStmt( const IfStmt & other );
         virtual ~IfStmt();
 
-        std::list<Statement *> &get_initialization() { return initialization; }
-        Expression *get_condition() { return condition; }
-        void set_condition( Expression *newValue ) { condition = newValue; }
-        Statement *get_thenPart() { return thenPart; }
-        void set_thenPart( Statement *newValue ) { thenPart = newValue; }
-        Statement *get_elsePart() { return elsePart; }
-        void set_elsePart( Statement *newValue ) { elsePart = newValue; }
-
-        virtual IfStmt *clone() const override { return new IfStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        std::list<Statement *> & get_initialization() { return initialization; }
+        Expression * get_condition() { return condition; }
+        void set_condition( Expression * newValue ) { condition = newValue; }
+        Statement * get_thenPart() { return thenPart; }
+        void set_thenPart( Statement * newValue ) { thenPart = newValue; }
+        Statement * get_elsePart() { return elsePart; }
+        void set_elsePart( Statement * newValue ) { elsePart = newValue; }
+
+        virtual IfStmt * clone() const override { return new IfStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -170 +177 @@
         std::list<Statement *> statements;
 
-        SwitchStmt( Expression *condition, const std::list<Statement *> &statements );
-        SwitchStmt( const SwitchStmt &other );
+        SwitchStmt( Expression * condition, const std::list<Statement *> & statements );
+        SwitchStmt( const SwitchStmt & other );
         virtual ~SwitchStmt();
 
-        Expression *get_condition() { return condition; }
-        void set_condition( Expression *newValue ) { condition = newValue; }
+        Expression * get_condition() { return condition; }
+        void set_condition( Expression * newValue ) { condition = newValue; }
 
         std::list<Statement *> & get_statements() { return statements; }
 
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-
-        virtual SwitchStmt *clone() const override { return new SwitchStmt( *this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+
+        virtual SwitchStmt * clone() const override { return new SwitchStmt( *this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 
 };
@@ -192 +200 @@
         std::list<Statement *> stmts;
 
-        CaseStmt( Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw (SemanticErrorException);
-        CaseStmt( const CaseStmt &other );
+        CaseStmt( Expression * conditions, const std::list<Statement *> & stmts, bool isdef = false ) throw (SemanticErrorException);
+        CaseStmt( const CaseStmt & other );
         virtual ~CaseStmt();
 
@@ -201 +209 @@
         void set_default(bool b) { _isDefault = b; }
 
-        Expression * &get_condition() { return condition; }
-        void set_condition( Expression *newValue ) { condition = newValue; }
-
-        std::list<Statement *> &get_statements() { return stmts; }
-        void set_statements( std::list<Statement *> &newValue ) { stmts = newValue; }
-
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-
-        virtual CaseStmt *clone() const override { return new CaseStmt( *this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        Expression * & get_condition() { return condition; }
+        void set_condition( Expression * newValue ) { condition = newValue; }
+
+        std::list<Statement *> & get_statements() { return stmts; }
+        void set_statements( std::list<Statement *> & newValue ) { stmts = newValue; }
+
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+
+        virtual CaseStmt * clone() const override { return new CaseStmt( *this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
   private:
         bool _isDefault;
@@ -218 +227 @@
 class WhileStmt : public Statement {
   public:
-        Expression *condition;
-        Statement *body;
+        Expression * condition;
+        Statement * body;
         std::list<Statement *> initialization;
         bool isDoWhile;
 
-        WhileStmt( Expression *condition,
-               Statement *body, std::list<Statement *> & initialization, bool isDoWhile = false );
-        WhileStmt( const WhileStmt &other );
+        WhileStmt( Expression * condition, Statement * body, std::list<Statement *> & initialization, bool isDoWhile = false );
+        WhileStmt( const WhileStmt & other );
         virtual ~WhileStmt();
 
-        Expression *get_condition() { return condition; }
-        void set_condition( Expression *newValue ) { condition = newValue; }
-        Statement *get_body() { return body; }
-        void set_body( Statement *newValue ) { body = newValue; }
+        Expression * get_condition() { return condition; }
+        void set_condition( Expression * newValue ) { condition = newValue; }
+        Statement * get_body() { return body; }
+        void set_body( Statement * newValue ) { body = newValue; }
         bool get_isDoWhile() { return isDoWhile; }
         void set_isDoWhile( bool newValue ) { isDoWhile = newValue; }
 
-        virtual WhileStmt *clone() const override { return new WhileStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual WhileStmt * clone() const override { return new WhileStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -244 +253 @@
   public:
         std::list<Statement *> initialization;
-        Expression *condition;
-        Expression *increment;
-        Statement *body;
-
-        ForStmt( std::list<Statement *> initialization,
-             Expression *condition = 0, Expression *increment = 0, Statement *body = 0 );
-        ForStmt( const ForStmt &other );
+        Expression * condition;
+        Expression * increment;
+        Statement * body;
+
+        ForStmt( std::list<Statement *> initialization, Expression * condition = 0, Expression * increment = 0, Statement * body = 0 );
+        ForStmt( const ForStmt & other );
         virtual ~ForStmt();
 
-        std::list<Statement *> &get_initialization() { return initialization; }
-        Expression *get_condition() { return condition; }
-        void set_condition( Expression *newValue ) { condition = newValue; }
-        Expression *get_increment() { return increment; }
-        void set_increment( Expression *newValue ) { increment = newValue; }
-        Statement *get_body() { return body; }
-        void set_body( Statement *newValue ) { body = newValue; }
-
-        virtual ForStmt *clone() const override { return new ForStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        std::list<Statement *> & get_initialization() { return initialization; }
+        Expression * get_condition() { return condition; }
+        void set_condition( Expression * newValue ) { condition = newValue; }
+        Expression * get_increment() { return increment; }
+        void set_increment( Expression * newValue ) { increment = newValue; }
+        Statement * get_body() { return body; }
+        void set_body( Statement * newValue ) { body = newValue; }
+
+        virtual ForStmt * clone() const override { return new ForStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -274 +283 @@
         const Label originalTarget;
         Label target;
-        Expression *computedTarget;
+        Expression * computedTarget;
         Type type;
 
         BranchStmt( Label target, Type ) throw (SemanticErrorException);
-        BranchStmt( Expression *computedTarget, Type ) throw (SemanticErrorException);
+        BranchStmt( Expression * computedTarget, Type ) throw (SemanticErrorException);
 
         Label get_originalTarget() { return originalTarget; }
@@ -284 +293 @@
         void set_target( Label newValue ) { target = newValue; }
 
-        Expression *get_computedTarget() { return computedTarget; }
+        Expression * get_computedTarget() { return computedTarget; }
         void set_target( Expression * newValue ) { computedTarget = newValue; }
 
         Type get_type() { return type; }
-        const char *get_typename() { return brType[ type ]; }
-
-        virtual BranchStmt *clone() const override { return new BranchStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        const char * get_typename() { return brType[ type ]; }
+
+        virtual BranchStmt * clone() const override { return new BranchStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
   private:
-        static const char *brType[];
+        static const char * brType[];
 };
 
 class ReturnStmt : public Statement {
   public:
-        Expression *expr;
-
-        ReturnStmt( Expression *expr );
-        ReturnStmt( const ReturnStmt &other );
+        Expression * expr;
+
+        ReturnStmt( Expression * expr );
+        ReturnStmt( const ReturnStmt & other );
         virtual ~ReturnStmt();
 
-        Expression *get_expr() { return expr; }
-        void set_expr( Expression *newValue ) { expr = newValue; }
-
-        virtual ReturnStmt *clone() const override { return new ReturnStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        Expression * get_expr() { return expr; }
+        void set_expr( Expression * newValue ) { expr = newValue; }
+
+        virtual ReturnStmt * clone() const override { return new ReturnStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -324 +335 @@
 
         ThrowStmt( Kind kind, Expression * expr, Expression * target = nullptr );
-        ThrowStmt( const ThrowStmt &other );
+        ThrowStmt( const ThrowStmt & other );
         virtual ~ThrowStmt();
 
@@ -333 +344 @@
         void set_target( Expression * newTarget ) { target = newTarget; }
 
-        virtual ThrowStmt *clone() const override { return new ThrowStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual ThrowStmt * clone() const override { return new ThrowStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -345 +357 @@
         FinallyStmt * finallyBlock;
 
-        TryStmt( CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 );
-        TryStmt( const TryStmt &other );
+        TryStmt( CompoundStmt * tryBlock, std::list<CatchStmt *> & handlers, FinallyStmt * finallyBlock = 0 );
+        TryStmt( const TryStmt & other );
         virtual ~TryStmt();
 
-        CompoundStmt *get_block() const { return block; }
-        void set_block( CompoundStmt *newValue ) { block = newValue; }
+        CompoundStmt * get_block() const { return block; }
+        void set_block( CompoundStmt * newValue ) { block = newValue; }
         std::list<CatchStmt *>& get_catchers() { return handlers; }
 
-        FinallyStmt *get_finally() const { return finallyBlock; }
-        void set_finally( FinallyStmt *newValue ) { finallyBlock = newValue; }
-
-        virtual TryStmt *clone() const override { return new TryStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        FinallyStmt * get_finally() const { return finallyBlock; }
+        void set_finally( FinallyStmt * newValue ) { finallyBlock = newValue; }
+
+        virtual TryStmt * clone() const override { return new TryStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -367 +380 @@
 
         const Kind kind;
-        Declaration *decl;
-        Expression *cond;
-        Statement *body;
-
-        CatchStmt( Kind kind, Declaration *decl,
-                   Expression *cond, Statement *body );
-        CatchStmt( const CatchStmt &other );
+        Declaration * decl;
+        Expression * cond;
+        Statement * body;
+
+        CatchStmt( Kind kind, Declaration * decl,
+                   Expression * cond, Statement * body );
+        CatchStmt( const CatchStmt & other );
         virtual ~CatchStmt();
 
         Kind get_kind() { return kind; }
-        Declaration *get_decl() { return decl; }
-        void set_decl( Declaration *newValue ) { decl = newValue; }
-        Expression *get_cond() { return cond; }
-        void set_cond( Expression *newCond ) { cond = newCond; }
-        Statement *get_body() { return body; }
-        void set_body( Statement *newValue ) { body = newValue; }
-
-        virtual CatchStmt *clone() const override { return new CatchStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        Declaration * get_decl() { return decl; }
+        void set_decl( Declaration * newValue ) { decl = newValue; }
+        Expression * get_cond() { return cond; }
+        void set_cond( Expression * newCond ) { cond = newCond; }
+        Statement * get_body() { return body; }
+        void set_body( Statement * newValue ) { body = newValue; }
+
+        virtual CatchStmt * clone() const override { return new CatchStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
 class FinallyStmt : public Statement {
   public:
-        CompoundStmt *block;
-
-        FinallyStmt( CompoundStmt *block );
-        FinallyStmt( const FinallyStmt &other );
+        CompoundStmt * block;
+
+        FinallyStmt( CompoundStmt * block );
+        FinallyStmt( const FinallyStmt & other );
         virtual ~FinallyStmt();
 
-        CompoundStmt *get_block() const { return block; }
-        void set_block( CompoundStmt *newValue ) { block = newValue; }
-
-        virtual FinallyStmt *clone() const override { return new FinallyStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        CompoundStmt * get_block() const { return block; }
+        void set_block( CompoundStmt * newValue ) { block = newValue; }
+
+        virtual FinallyStmt * clone() const override { return new FinallyStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -438 +453 @@
         } orelse;
 
-        virtual WaitForStmt *clone() const override { return new WaitForStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
-
-};
-
-class WithStmt : public Statement {
-public:
-        std::list< Expression * > exprs;
-        Statement * stmt;
-
-        WithStmt( const std::list< Expression * > & exprs, Statement * stmt );
-        WithStmt( const WithStmt & other );
-        virtual ~WithStmt();
-
-        virtual WithStmt * clone() const override { return new WithStmt( *this ); }
-        virtual void accept( Visitor & v ) override { v.visit( this ); }
-        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
-};
+        virtual WaitForStmt * clone() const override { return new WaitForStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+
+};
+
+// class WithStmt : public Statement {
+// public:
+//      std::list< Expression * > exprs;
+//      Statement * stmt;
+
+//      WithStmt( const std::list< Expression * > & exprs, Statement * stmt );
+//      WithStmt( const WithStmt & other );
+//      virtual ~WithStmt();
+
+//      virtual WithStmt * clone() const override { return new WithStmt( *this ); }
+//      virtual void accept( Visitor & v ) override { v.visit( this ); }
+//      virtual void accept( Visitor & v ) const override { v.visit( this ); }
+//      virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+//      virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+// };
 
 
@@ -464 +481 @@
 class DeclStmt : public Statement {
   public:
-        Declaration *decl;
-
-        DeclStmt( Declaration *decl );
-        DeclStmt( const DeclStmt &other );
+        Declaration * decl;
+
+        DeclStmt( Declaration * decl );
+        DeclStmt( const DeclStmt & other );
         virtual ~DeclStmt();
 
-        Declaration *get_decl() const { return decl; }
-        void set_decl( Declaration *newValue ) { decl = newValue; }
-
-        virtual DeclStmt *clone() const override { return new DeclStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
-};
-
-
-/// represents an implicit application of a constructor or destructor. Qualifiers are replaced
-/// immediately before and after the call so that qualified objects can be constructed
-/// with the same functions as unqualified objects.
+        Declaration * get_decl() const { return decl; }
+        void set_decl( Declaration * newValue ) { decl = newValue; }
+
+        virtual DeclStmt * clone() const override { return new DeclStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
+
+
+/// represents an implicit application of a constructor or destructor. Qualifiers are replaced immediately before and
+/// after the call so that qualified objects can be constructed with the same functions as unqualified objects.
 class ImplicitCtorDtorStmt : public Statement {
   public:
@@ -492 +509 @@
         virtual ~ImplicitCtorDtorStmt();
 
-        Statement *get_callStmt() const { return callStmt; }
+        Statement * get_callStmt() const { return callStmt; }
         void set_callStmt( Statement * newValue ) { callStmt = newValue; }
 
-        virtual ImplicitCtorDtorStmt *clone() const override { return new ImplicitCtorDtorStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual ImplicitCtorDtorStmt * clone() const override { return new ImplicitCtorDtorStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 

src/SynTree/SynTree.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Jul 24 16:54:00 2017
-// Update Count     : 11
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Jul 25 22:37:45 2019
+// Update Count     : 12
 //
 
@@ -34 +34 @@
 class NamedTypeDecl;
 class TypeDecl;
-class FtypeDecl;
-class DtypeDecl;
 class TypedefDecl;
 class AsmDecl;
@@ -81 +79 @@
 class OffsetofExpr;
 class OffsetPackExpr;
-class AttrExpr;
 class LogicalExpr;
 class ConditionalExpr;
@@ -90 +87 @@
 class ConstructorExpr;
 class CompoundLiteralExpr;
-class UntypedValofExpr;
 class RangeExpr;
 class UntypedTupleExpr;
@@ -101 +97 @@
 class InitExpr;
 class DeletedExpr;
+class DefaultArgExpr;
 class GenericExpr;
 
@@ -109 +106 @@
 class ArrayType;
 class ReferenceType;
+class QualifiedType;
 class FunctionType;
 class ReferenceToType;
@@ -122 +120 @@
 class ZeroType;
 class OneType;
+class GlobalScopeType;
 
 class Designation;
@@ -128 +127 @@
 class ListInit;
 class ConstructorInit;
-
-class Subrange;
 
 //template <class T>    // emulate a union with templates?

src/SynTree/TupleExpr.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 17 09:42:29 2017
-// Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug 14 14:34:00 2019
+// Update Count     : 5
 //
 
@@ -57 +57 @@
 }
 
+bool TupleExpr::get_lvalue() const {
+        return false;
+}
+
 void TupleExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Tuple:" << std::endl;
@@ -67 +71 @@
         assertf( type->size() > index, "TupleIndexExpr index out of bounds: tuple size %d, requested index %d in expr %s", type->size(), index, toString( tuple ).c_str() );
         set_result( (*std::next( type->get_types().begin(), index ))->clone() );
-        // like MemberExpr, TupleIndexExpr is always an lvalue
-        get_result()->set_lvalue( true );
 }
 
@@ -76 +78 @@
 TupleIndexExpr::~TupleIndexExpr() {
         delete tuple;
+}
+
+bool TupleIndexExpr::get_lvalue() const {
+        return tuple->get_lvalue();
 }
 
@@ -105 +111 @@
 }
 
+TupleAssignExpr::TupleAssignExpr( 
+        StmtExpr * s )
+: Expression(), stmtExpr(s) {
+}
+
+
 TupleAssignExpr::~TupleAssignExpr() {
         delete stmtExpr;

src/SynTree/Type.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 25 15:16:32 2017
-// Update Count     : 38
+// Last Modified On : Sun Aug  4 21:05:07 2019
+// Update Count     : 45
 //
 #include "Type.h"
@@ -24 +24 @@
 using namespace std;
 
-const char *BasicType::typeNames[] = {
+const char * BasicType::typeNames[] = {
         "_Bool",
         "char",
@@ -37 +37 @@
         "signed long long int",
         "unsigned long long int",
-        "float",
-        "double",
-        "long double",
-        "float _Complex",
-        "double _Complex",
-        "long double _Complex",
-        "float _Imaginary",
-        "double _Imaginary",
-        "long double _Imaginary",
         "__int128",
         "unsigned __int128",
+        "_Float16",
+        "_Float16 _Complex",
+        "_Float32",
+        "_Float32 _Complex",
+        "float",
+        "float _Complex",
+        //"float _Imaginary",
+        "_Float32x",
+        "_Float32x _Complex",
+        "_Float64",
+        "_Float64 _Complex",
+        "double",
+        "double _Complex",
+        //"double _Imaginary",
+        "_Float64x",
+        "_Float64x _Complex",
         "__float80",
-        "__float128"
+        "_Float128",
+        "_Float128 _Complex",
+        "__float128",
+        "long double",
+        "long double _Complex",
+        //"long double _Imaginary",
+        "_Float128x",
+        "_Float128x _Complex",
 };
 static_assert(
-        sizeof(BasicType::typeNames)/sizeof(BasicType::typeNames[0]) == BasicType::NUMBER_OF_BASIC_TYPES,
+        sizeof(BasicType::typeNames) / sizeof(BasicType::typeNames[0]) == BasicType::NUMBER_OF_BASIC_TYPES,
         "Each basic type name should have a corresponding kind enum value"
 );
@@ -69 +83 @@
 
 // These must remain in the same order as the corresponding bit fields.
-const char * Type::FuncSpecifiersNames[] = { "inline", "fortran", "_Noreturn" };
+const char * Type::FuncSpecifiersNames[] = { "inline", "_Noreturn", "fortran" };
 const char * Type::StorageClassesNames[] = { "extern", "static", "auto", "register", "_Thread_local" };
-const char * Type::QualifiersNames[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic" };
+const char * Type::QualifiersNames[] = { "const", "restrict", "volatile", "mutex", "_Atomic" };
 
 Type * Type::stripDeclarator() {
@@ -86 +100 @@
 }
 
+const Type * Type::stripReferences() const {
+        const Type * type;
+        const ReferenceType * ref;
+        for ( type = this; (ref = dynamic_cast<const ReferenceType *>( type )); type = ref->base );
+        return type;
+}
+
 int Type::referenceDepth() const { return 0; }
 
 TypeSubstitution Type::genericSubstitution() const { assertf( false, "Non-aggregate type: %s", toCString( this ) ); }
 
-void Type::print( std::ostream &os, Indenter indent ) const {
+void Type::print( std::ostream & os, Indenter indent ) const {
         if ( ! forall.empty() ) {
                 os << "forall" << std::endl;
@@ -105 +126 @@
 }
 
+
+QualifiedType::QualifiedType( const Type::Qualifiers & tq, Type * parent, Type * child ) : Type( tq, {} ), parent( parent ), child( child ) {
+}
+
+QualifiedType::QualifiedType( const QualifiedType & other ) : Type( other ), parent( maybeClone( other.parent ) ), child( maybeClone( other.child ) ) {
+}
+
+QualifiedType::~QualifiedType() {
+        delete parent;
+        delete child;
+}
+
+void QualifiedType::print( std::ostream & os, Indenter indent ) const {
+        os << "Qualified Type:" << endl;
+        os << indent+1;
+        parent->print( os, indent+1 );
+        os << endl << indent+1;
+        child->print( os, indent+1 );
+        os << endl;
+        Type::print( os, indent+1 );
+}
+
+GlobalScopeType::GlobalScopeType() : Type( Type::Qualifiers(), {} ) {}
+
+void GlobalScopeType::print( std::ostream & os, Indenter ) const {
+        os << "Global Scope Type" << endl;
+}
+
+
 // Empty Variable declarations:
 const Type::FuncSpecifiers noFuncSpecifiers;

src/SynTree/Type.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 25 14:14:01 2017
-// Update Count     : 154
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Sep  4 09:58:00 2019
+// Update Count     : 170
 //
 
@@ -102 +102 @@
         }; // StorageClasses
 
-        enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Lvalue = 1 << 3, Mutex = 1 << 4, Atomic = 1 << 5, NumTypeQualifier = 6 };
+        enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Mutex = 1 << 3, Atomic = 1 << 4, NumTypeQualifier = 5 };
         static const char * QualifiersNames[];
         union Qualifiers {
-                enum { Mask = ~(Restrict | Lvalue) };
+                enum { Mask = ~Restrict };
                 unsigned int val;
                 struct {
@@ -111 +111 @@
                         bool is_restrict : 1;
                         bool is_volatile : 1;
-                        bool is_lvalue : 1;
                         bool is_mutex : 1;
                         bool is_atomic : 1;
@@ -131 +130 @@
                 bool operator>( Qualifiers other ) const { return *this != other && *this >= other; }
                 BFCommon( Qualifiers, NumTypeQualifier )
+
+                Qualifiers unify( Qualifiers const & other ) const {
+                        int or_flags = Mask & (val | other.val);
+                        int and_flags = val & other.val;
+                        return Qualifiers( or_flags | and_flags );
+                }
         }; // Qualifiers
 
@@ -144 +149 @@
 
         Qualifiers & get_qualifiers() { return tq; }
-        bool get_const() { return tq.is_const; }
-        bool get_volatile() { return tq.is_volatile; }
-        bool get_restrict() { return tq.is_restrict; }
-        bool get_lvalue() { return tq.is_lvalue; }
-        bool get_mutex() { return tq.is_mutex; }
-        bool get_atomic() { return tq.is_atomic; }
+        bool get_const() const { return tq.is_const; }
+        bool get_volatile() const { return tq.is_volatile; }
+        bool get_restrict() const { return tq.is_restrict; }
+        bool get_mutex() const { return tq.is_mutex; }
+        bool get_atomic() const { return tq.is_atomic; }
         void set_const( bool newValue ) { tq.is_const = newValue; }
         void set_volatile( bool newValue ) { tq.is_volatile = newValue; }
         void set_restrict( bool newValue ) { tq.is_restrict = newValue; }
-        void set_lvalue( bool newValue ) { tq.is_lvalue = newValue; }
         void set_mutex( bool newValue ) { tq.is_mutex = newValue; }
         void set_atomic( bool newValue ) { tq.is_atomic = newValue; }
@@ -172 +175 @@
         /// return type without outer references
         Type * stripReferences();
+        const Type * stripReferences() const;
 
         /// return the number of references occuring consecutively on the outermost layer of this type (i.e. do not count references nested within other types)
@@ -178 +182 @@
         virtual bool isComplete() const { return true; }
 
-        virtual AggregateDecl * getAggr() { assertf( false, "Non-aggregate type: %s", toCString( this ) ); }
+        virtual AggregateDecl * getAggr() const { assertf( false, "Non-aggregate type: %s", toCString( this ) ); }
 
         virtual TypeSubstitution genericSubstitution() const;
@@ -184 +188 @@
         virtual Type *clone() const = 0;
         virtual void accept( Visitor & v ) = 0;
+        virtual void accept( Visitor & v ) const = 0;
         virtual Type *acceptMutator( Mutator & m ) = 0;
         virtual void print( std::ostream & os, Indenter indent = {} ) const;
@@ -201 +206 @@
         virtual VoidType *clone() const override { return new VoidType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
@@ -207 +213 @@
 class BasicType : public Type {
   public:
+        // GENERATED START, DO NOT EDIT
+        // GENERATED BY BasicTypes-gen.cc
         enum Kind {
                 Bool,
@@ -220 +228 @@
                 LongLongSignedInt,
                 LongLongUnsignedInt,
-                Float,
-                Double,
-                LongDouble,
-                FloatComplex,
-                DoubleComplex,
-                LongDoubleComplex,
-                FloatImaginary,
-                DoubleImaginary,
-                LongDoubleImaginary,
                 SignedInt128,
                 UnsignedInt128,
-                Float80,
-                Float128,
+                uFloat16,
+                uFloat16Complex,
+                uFloat32,
+                uFloat32Complex,
+                Float,
+                FloatComplex,
+                uFloat32x,
+                uFloat32xComplex,
+                uFloat64,
+                uFloat64Complex,
+                Double,
+                DoubleComplex,
+                uFloat64x,
+                uFloat64xComplex,
+                uuFloat80,
+                uFloat128,
+                uFloat128Complex,
+                uuFloat128,
+                LongDouble,
+                LongDoubleComplex,
+                uFloat128x,
+                uFloat128xComplex,
                 NUMBER_OF_BASIC_TYPES
         } kind;
+        // GENERATED END
 
         static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
@@ -240 +260 @@
         BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
 
-        Kind get_kind() { return kind; }
+        Kind get_kind() const { return kind; }
         void set_kind( Kind newValue ) { kind = newValue; }
 
         virtual BasicType *clone() const override { return new BasicType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
@@ -280 +301 @@
         virtual PointerType *clone() const override { return new PointerType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
@@ -311 +333 @@
         virtual ArrayType *clone() const override { return new ArrayType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
+
+class QualifiedType : public Type {
+public:
+        Type * parent;
+        Type * child;
+
+        QualifiedType( const Type::Qualifiers & tq, Type * parent, Type * child );
+        QualifiedType( const QualifiedType & tq );
+        virtual ~QualifiedType();
+
+        virtual QualifiedType *clone() const override { return new QualifiedType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
@@ -337 +376 @@
         virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
@@ -366 +406 @@
         virtual FunctionType *clone() const override { return new FunctionType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
@@ -416 +457 @@
         virtual bool isComplete() const override;
 
-        virtual AggregateDecl * getAggr() override;
+        virtual AggregateDecl * getAggr() const override;
 
         virtual TypeSubstitution genericSubstitution() const override;
@@ -426 +467 @@
         virtual StructInstType *clone() const override { return new StructInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
 
@@ -453 +495 @@
         virtual bool isComplete() const override;
 
-        virtual AggregateDecl * getAggr() override;
+        virtual AggregateDecl * getAggr() const override;
 
         virtual TypeSubstitution genericSubstitution() const override;
@@ -463 +505 @@
         virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
 
@@ -486 +529 @@
         virtual bool isComplete() const override;
 
+        virtual AggregateDecl * getAggr() const override;
+
         virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
 
@@ -511 +557 @@
         virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
   private:
@@ -538 +585 @@
         virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
@@ -575 +623 @@
         virtual TupleType *clone() const override { return new TupleType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
@@ -581 +630 @@
 class TypeofType : public Type {
   public:
-        Expression *expr;
-
-        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        Expression *expr;    ///< expression to take the type of
+        bool is_basetypeof;  ///< true iff is basetypeof type
+
+        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof,
+                const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         TypeofType( const TypeofType& );
         virtual ~TypeofType();
@@ -594 +646 @@
         virtual TypeofType *clone() const override { return new TypeofType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
@@ -623 +676 @@
         virtual AttrType *clone() const override { return new AttrType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
@@ -637 +691 @@
         virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
@@ -649 +704 @@
         virtual ZeroType *clone() const override { return new ZeroType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
@@ -661 +717 @@
         virtual OneType *clone() const override { return new OneType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
+
+class GlobalScopeType : public Type {
+  public:
+        GlobalScopeType();
+
+        virtual GlobalScopeType *clone() const override { return new GlobalScopeType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;

src/SynTree/TypeSubstitution.cc

@@ -64 +64 @@
 }
 
+void TypeSubstitution::addVar( std::string formalExpr, Expression *actualExpr ) {
+        varEnv[ formalExpr ] = actualExpr;
+}
+
 void TypeSubstitution::remove( std::string formalType ) {
         TypeEnvType::iterator i = typeEnv.find( formalType );
@@ -108 +112 @@
 namespace {
         struct EnvTrimmer {
-                TypeSubstitution * env, * newEnv;
-                EnvTrimmer( TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
+                const TypeSubstitution * env;
+                TypeSubstitution * newEnv;
+                EnvTrimmer( const TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
                 void previsit( TypeDecl * tyDecl ) {
                         // transfer known bindings for seen type variables
@@ -120 +125 @@
 
 /// reduce environment to just the parts that are referenced in a given expression
-TypeSubstitution * TypeSubstitution::newFromExpr( Expression * expr, TypeSubstitution * env ) {
+TypeSubstitution * TypeSubstitution::newFromExpr( Expression * expr, const TypeSubstitution * env ) {
         if ( env ) {
                 TypeSubstitution * newEnv = new TypeSubstitution();

src/SynTree/TypeSubstitution.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:52:24 2017
-// Update Count     : 3
+// Last Modified On : Tue Apr 30 22:52:47 2019
+// Update Count     : 9
 //
 
@@ -19 +19 @@
 #include <iosfwd>                  // for ostream
 #include <list>                    // for list<>::iterator, _List_iterator
-#include <map>                     // for _Rb_tree_iterator, map, map<>::val...
-#include <set>                     // for set
+#include <unordered_map>
+#include <unordered_set>
 #include <string>                  // for string, operator!=
 #include <utility>                 // for pair
@@ -39 +39 @@
         TypeSubstitution &operator=( const TypeSubstitution &other );
 
-        template< typename SynTreeClass > int apply( SynTreeClass *&input );
-        template< typename SynTreeClass > int applyFree( SynTreeClass *&input );
+        template< typename SynTreeClass > int apply( SynTreeClass *&input ) const;
+        template< typename SynTreeClass > int applyFree( SynTreeClass *&input ) const;
 
         void add( std::string formalType, Type *actualType );
@@ -48 +48 @@
         bool empty() const;
 
+        void addVar( std::string formalExpr, Expression *actualExpr );
+
         template< typename FormalIterator, typename ActualIterator >
         void add( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin );
@@ -56 +58 @@
 
         /// create a new TypeSubstitution using bindings from env containing all of the type variables in expr
-        static TypeSubstitution * newFromExpr( Expression * expr, TypeSubstitution * env );
+        static TypeSubstitution * newFromExpr( Expression * expr, const TypeSubstitution * env );
 
         void normalize();
@@ -78 +80 @@
         friend class PassVisitor;
 
-        typedef std::map< std::string, Type* > TypeEnvType;
-        typedef std::map< std::string, Expression* > VarEnvType;
+        typedef std::unordered_map< std::string, Type * > TypeEnvType;
+        typedef std::unordered_map< std::string, Expression * > VarEnvType;
         TypeEnvType typeEnv;
         VarEnvType varEnv;
@@ -89 +91 @@
         auto begin() const -> decltype( typeEnv.begin() ) { return typeEnv.begin(); }
         auto   end() const -> decltype( typeEnv.  end() ) { return typeEnv.  end(); }
+
+        auto beginVar()       -> decltype( varEnv.begin() ) { return varEnv.begin(); }
+        auto   endVar()       -> decltype( varEnv.  end() ) { return varEnv.  end(); }
+        auto beginVar() const -> decltype( varEnv.begin() ) { return varEnv.begin(); }
+        auto   endVar() const -> decltype( varEnv.  end() ) { return varEnv.  end(); }
 };
 
@@ -98 +105 @@
         ActualIterator actualIt = actualBegin;
         for ( ; formalIt != formalEnd; ++formalIt, ++actualIt ) {
-                if ( TypeDecl *formal = dynamic_cast< TypeDecl* >( *formalIt ) ) {
-                        if ( TypeExpr *actual = dynamic_cast< TypeExpr* >( *actualIt ) ) {
+                if ( TypeDecl *formal = dynamic_cast< TypeDecl * >( *formalIt ) ) {
+                        if ( TypeExpr *actual = dynamic_cast< TypeExpr * >( *actualIt ) ) {
                                 if ( formal->get_name() != "" ) {
                                         TypeEnvType::iterator i = typeEnv.find( formal->get_name() );
@@ -130 +137 @@
 // definitition must happen after PassVisitor is included so that WithGuards can be used
 struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter> {
-                Substituter( TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
+                Substituter( const TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
 
                 Type * postmutate( TypeInstType * aggregateUseType );
@@ -143 +150 @@
                 void premutate( UnionInstType * aggregateUseType );
 
-                TypeSubstitution & sub;
+                const TypeSubstitution & sub;
                 int subCount = 0;
                 bool freeOnly;
-                typedef std::set< std::string > BoundVarsType;
+                typedef std::unordered_set< std::string > BoundVarsType;
                 BoundVarsType boundVars;
 };
 
 template< typename SynTreeClass >
-int TypeSubstitution::apply( SynTreeClass *&input ) {
+int TypeSubstitution::apply( SynTreeClass *&input ) const {
         assert( input );
         PassVisitor<Substituter> sub( *this, false );
@@ -163 +170 @@
 
 template< typename SynTreeClass >
-int TypeSubstitution::applyFree( SynTreeClass *&input ) {
+int TypeSubstitution::applyFree( SynTreeClass *&input ) const {
         assert( input );
         PassVisitor<Substituter> sub( *this, true );

src/SynTree/TypeofType.cc

@@ -23 +23 @@
 class Attribute;
 
-TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), expr( expr ) {
-}
+TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, 
+        const std::list< Attribute * > & attributes ) 
+: Type( tq, attributes ), expr( expr ), is_basetypeof(false) {}
 
-TypeofType::TypeofType( const TypeofType &other ) : Type( other ), expr( maybeClone( other.expr ) ) {
-}
+TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, bool is_basetypeof, 
+        const std::list< Attribute * > & attributes ) 
+: Type( tq, attributes ), expr( expr ), is_basetypeof( is_basetypeof ) {}
+
+TypeofType::TypeofType( const TypeofType &other )
+: Type( other ), expr( maybeClone( other.expr ) ), is_basetypeof( other.is_basetypeof ) {}
 
 TypeofType::~TypeofType() {
@@ -35 +40 @@
 void TypeofType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
+        if ( is_basetypeof ) { os << "base-"; }
         os << "type-of expression ";
         if ( expr ) {

src/SynTree/Visitor.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Jul 24 16:28:00 2017
-// Update Count     : 13
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Jul 25 22:21:49 2019
+// Update Count     : 14
 //
 
@@ -27 +27 @@
         // of the given syntax node, but performs no other action.
 
-        virtual void visit( ObjectDecl * objectDecl ) = 0;
-        virtual void visit( FunctionDecl * functionDecl ) = 0;
-        virtual void visit( StructDecl * aggregateDecl ) = 0;
-        virtual void visit( UnionDecl * aggregateDecl ) = 0;
-        virtual void visit( EnumDecl * aggregateDecl ) = 0;
-        virtual void visit( TraitDecl * aggregateDecl ) = 0;
-        virtual void visit( TypeDecl * typeDecl ) = 0;
-        virtual void visit( TypedefDecl * typeDecl ) = 0;
-        virtual void visit( AsmDecl * asmDecl ) = 0;
-        virtual void visit( StaticAssertDecl * assertDecl ) = 0;
-
-        virtual void visit( CompoundStmt * compoundStmt ) = 0;
-        virtual void visit( ExprStmt * exprStmt ) = 0;
-        virtual void visit( AsmStmt * asmStmt ) = 0;
-        virtual void visit( DirectiveStmt * directiveStmt ) = 0;
-        virtual void visit( IfStmt * ifStmt ) = 0;
-        virtual void visit( WhileStmt * whileStmt ) = 0;
-        virtual void visit( ForStmt * forStmt ) = 0;
-        virtual void visit( SwitchStmt * switchStmt ) = 0;
-        virtual void visit( CaseStmt * caseStmt ) = 0;
-        virtual void visit( BranchStmt * branchStmt ) = 0;
-        virtual void visit( ReturnStmt * returnStmt ) = 0;
-        virtual void visit( ThrowStmt * throwStmt ) = 0;
-        virtual void visit( TryStmt * tryStmt ) = 0;
-        virtual void visit( CatchStmt * catchStmt ) = 0;
-        virtual void visit( FinallyStmt * finallyStmt ) = 0;
-        virtual void visit( WaitForStmt * waitforStmt ) = 0;
-        virtual void visit( WithStmt * withStmt ) = 0;
-        virtual void visit( NullStmt * nullStmt ) = 0;
-        virtual void visit( DeclStmt * declStmt ) = 0;
-        virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) = 0;
-
-        virtual void visit( ApplicationExpr * applicationExpr ) = 0;
-        virtual void visit( UntypedExpr * untypedExpr ) = 0;
-        virtual void visit( NameExpr * nameExpr ) = 0;
-        virtual void visit( CastExpr * castExpr ) = 0;
-        virtual void visit( KeywordCastExpr * castExpr ) = 0;
-        virtual void visit( VirtualCastExpr * castExpr ) = 0;
-        virtual void visit( AddressExpr * addressExpr ) = 0;
-        virtual void visit( LabelAddressExpr * labAddressExpr ) = 0;
-        virtual void visit( UntypedMemberExpr * memberExpr ) = 0;
-        virtual void visit( MemberExpr * memberExpr ) = 0;
-        virtual void visit( VariableExpr * variableExpr ) = 0;
-        virtual void visit( ConstantExpr * constantExpr ) = 0;
-        virtual void visit( SizeofExpr * sizeofExpr ) = 0;
-        virtual void visit( AlignofExpr * alignofExpr ) = 0;
-        virtual void visit( UntypedOffsetofExpr * offsetofExpr ) = 0;
-        virtual void visit( OffsetofExpr * offsetofExpr ) = 0;
-        virtual void visit( OffsetPackExpr * offsetPackExpr ) = 0;
-        virtual void visit( AttrExpr * attrExpr ) = 0;
-        virtual void visit( LogicalExpr * logicalExpr ) = 0;
-        virtual void visit( ConditionalExpr * conditionalExpr ) = 0;
-        virtual void visit( CommaExpr * commaExpr ) = 0;
-        virtual void visit( TypeExpr * typeExpr ) = 0;
-        virtual void visit( AsmExpr * asmExpr ) = 0;
-        virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) = 0;
-        virtual void visit( ConstructorExpr *  ctorExpr ) = 0;
-        virtual void visit( CompoundLiteralExpr * compLitExpr ) = 0;
-        virtual void visit( RangeExpr * rangeExpr ) = 0;
-        virtual void visit( UntypedTupleExpr * tupleExpr ) = 0;
-        virtual void visit( TupleExpr * tupleExpr ) = 0;
-        virtual void visit( TupleIndexExpr * tupleExpr ) = 0;
-        virtual void visit( TupleAssignExpr * assignExpr ) = 0;
-        virtual void visit( StmtExpr *  stmtExpr ) = 0;
-        virtual void visit( UniqueExpr *  uniqueExpr ) = 0;
-        virtual void visit( UntypedInitExpr *  initExpr ) = 0;
-        virtual void visit( InitExpr *  initExpr ) = 0;
-        virtual void visit( DeletedExpr * delExpr ) = 0;
-        virtual void visit( GenericExpr * genExpr ) = 0;
-
-        virtual void visit( VoidType * basicType ) = 0;
-        virtual void visit( BasicType * basicType ) = 0;
-        virtual void visit( PointerType * pointerType ) = 0;
-        virtual void visit( ArrayType * arrayType ) = 0;
-        virtual void visit( ReferenceType * refType ) = 0;
-        virtual void visit( FunctionType * functionType ) = 0;
-        virtual void visit( StructInstType * aggregateUseType ) = 0;
-        virtual void visit( UnionInstType * aggregateUseType ) = 0;
-        virtual void visit( EnumInstType * aggregateUseType ) = 0;
-        virtual void visit( TraitInstType * aggregateUseType ) = 0;
-        virtual void visit( TypeInstType * aggregateUseType ) = 0;
-        virtual void visit( TupleType * tupleType ) = 0;
-        virtual void visit( TypeofType * typeofType ) = 0;
-        virtual void visit( AttrType * attrType ) = 0;
-        virtual void visit( VarArgsType * varArgsType ) = 0;
-        virtual void visit( ZeroType * zeroType ) = 0;
-        virtual void visit( OneType * oneType ) = 0;
-
-        virtual void visit( Designation * designation ) = 0;
-        virtual void visit( SingleInit * singleInit ) = 0;
-        virtual void visit( ListInit * listInit ) = 0;
-        virtual void visit( ConstructorInit * ctorInit ) = 0;
-
-        virtual void visit( Subrange * subrange ) = 0;
-
-        virtual void visit( Constant * constant ) = 0;
-
-        virtual void visit( Attribute * attribute ) = 0;
+        virtual void visit( ObjectDecl * node ) { visit( const_cast<const ObjectDecl *>(node) ); }
+        virtual void visit( const ObjectDecl * objectDecl ) = 0;
+        virtual void visit( FunctionDecl * node ) { visit( const_cast<const FunctionDecl *>(node) ); }
+        virtual void visit( const FunctionDecl * functionDecl ) = 0;
+        virtual void visit( StructDecl * node ) { visit( const_cast<const StructDecl *>(node) ); }
+        virtual void visit( const StructDecl * aggregateDecl ) = 0;
+        virtual void visit( UnionDecl * node ) { visit( const_cast<const UnionDecl *>(node) ); }
+        virtual void visit( const UnionDecl * aggregateDecl ) = 0;
+        virtual void visit( EnumDecl * node ) { visit( const_cast<const EnumDecl *>(node) ); }
+        virtual void visit( const EnumDecl * aggregateDecl ) = 0;
+        virtual void visit( TraitDecl * node ) { visit( const_cast<const TraitDecl *>(node) ); }
+        virtual void visit( const TraitDecl * aggregateDecl ) = 0;
+        virtual void visit( TypeDecl * node ) { visit( const_cast<const TypeDecl *>(node) ); }
+        virtual void visit( const TypeDecl * typeDecl ) = 0;
+        virtual void visit( TypedefDecl * node ) { visit( const_cast<const TypedefDecl *>(node) ); }
+        virtual void visit( const TypedefDecl * typeDecl ) = 0;
+        virtual void visit( AsmDecl * node ) { visit( const_cast<const AsmDecl *>(node) ); }
+        virtual void visit( const AsmDecl * asmDecl ) = 0;
+        virtual void visit( StaticAssertDecl * node ) { visit( const_cast<const StaticAssertDecl *>(node) ); }
+        virtual void visit( const StaticAssertDecl * assertDecl ) = 0;
+
+        virtual void visit( CompoundStmt * node ) { visit( const_cast<const CompoundStmt *>(node) ); }
+        virtual void visit( const CompoundStmt * compoundStmt ) = 0;
+        virtual void visit( ExprStmt * node ) { visit( const_cast<const ExprStmt *>(node) ); }
+        virtual void visit( const ExprStmt * exprStmt ) = 0;
+        virtual void visit( AsmStmt * node ) { visit( const_cast<const AsmStmt *>(node) ); }
+        virtual void visit( const AsmStmt * asmStmt ) = 0;
+        virtual void visit( DirectiveStmt * node ) { visit( const_cast<const DirectiveStmt *>(node) ); }
+        virtual void visit( const DirectiveStmt * directiveStmt ) = 0;
+        virtual void visit( IfStmt * node ) { visit( const_cast<const IfStmt *>(node) ); }
+        virtual void visit( const IfStmt * ifStmt ) = 0;
+        virtual void visit( WhileStmt * node ) { visit( const_cast<const WhileStmt *>(node) ); }
+        virtual void visit( const WhileStmt * whileStmt ) = 0;
+        virtual void visit( ForStmt * node ) { visit( const_cast<const ForStmt *>(node) ); }
+        virtual void visit( const ForStmt * forStmt ) = 0;
+        virtual void visit( SwitchStmt * node ) { visit( const_cast<const SwitchStmt *>(node) ); }
+        virtual void visit( const SwitchStmt * switchStmt ) = 0;
+        virtual void visit( CaseStmt * node ) { visit( const_cast<const CaseStmt *>(node) ); }
+        virtual void visit( const CaseStmt * caseStmt ) = 0;
+        virtual void visit( BranchStmt * node ) { visit( const_cast<const BranchStmt *>(node) ); }
+        virtual void visit( const BranchStmt * branchStmt ) = 0;
+        virtual void visit( ReturnStmt * node ) { visit( const_cast<const ReturnStmt *>(node) ); }
+        virtual void visit( const ReturnStmt * returnStmt ) = 0;
+        virtual void visit( ThrowStmt * node ) { visit( const_cast<const ThrowStmt *>(node) ); }
+        virtual void visit( const ThrowStmt * throwStmt ) = 0;
+        virtual void visit( TryStmt * node ) { visit( const_cast<const TryStmt *>(node) ); }
+        virtual void visit( const TryStmt * tryStmt ) = 0;
+        virtual void visit( CatchStmt * node ) { visit( const_cast<const CatchStmt *>(node) ); }
+        virtual void visit( const CatchStmt * catchStmt ) = 0;
+        virtual void visit( FinallyStmt * node ) { visit( const_cast<const FinallyStmt *>(node) ); }
+        virtual void visit( const FinallyStmt * finallyStmt ) = 0;
+        virtual void visit( WaitForStmt * node ) { visit( const_cast<const WaitForStmt *>(node) ); }
+        virtual void visit( const WaitForStmt * waitforStmt ) = 0;
+        virtual void visit( WithStmt * node ) { visit( const_cast<const WithStmt *>(node) ); }
+        virtual void visit( const WithStmt * withStmt ) = 0;
+        virtual void visit( NullStmt * node ) { visit( const_cast<const NullStmt *>(node) ); }
+        virtual void visit( const NullStmt * nullStmt ) = 0;
+        virtual void visit( DeclStmt * node ) { visit( const_cast<const DeclStmt *>(node) ); }
+        virtual void visit( const DeclStmt * declStmt ) = 0;
+        virtual void visit( ImplicitCtorDtorStmt * node ) { visit( const_cast<const ImplicitCtorDtorStmt *>(node) ); }
+        virtual void visit( const ImplicitCtorDtorStmt * impCtorDtorStmt ) = 0;
+
+        virtual void visit( ApplicationExpr * node ) { visit( const_cast<const ApplicationExpr *>(node) ); }
+        virtual void visit( const ApplicationExpr * applicationExpr ) = 0;
+        virtual void visit( UntypedExpr * node ) { visit( const_cast<const UntypedExpr *>(node) ); }
+        virtual void visit( const UntypedExpr * untypedExpr ) = 0;
+        virtual void visit( NameExpr * node ) { visit( const_cast<const NameExpr *>(node) ); }
+        virtual void visit( const NameExpr * nameExpr ) = 0;
+        virtual void visit( CastExpr * node ) { visit( const_cast<const CastExpr *>(node) ); }
+        virtual void visit( const CastExpr * castExpr ) = 0;
+        virtual void visit( KeywordCastExpr * node ) { visit( const_cast<const KeywordCastExpr *>(node) ); }
+        virtual void visit( const KeywordCastExpr * castExpr ) = 0;
+        virtual void visit( VirtualCastExpr * node ) { visit( const_cast<const VirtualCastExpr *>(node) ); }
+        virtual void visit( const VirtualCastExpr * castExpr ) = 0;
+        virtual void visit( AddressExpr * node ) { visit( const_cast<const AddressExpr *>(node) ); }
+        virtual void visit( const AddressExpr * addressExpr ) = 0;
+        virtual void visit( LabelAddressExpr * node ) { visit( const_cast<const LabelAddressExpr *>(node) ); }
+        virtual void visit( const LabelAddressExpr * labAddressExpr ) = 0;
+        virtual void visit( UntypedMemberExpr * node ) { visit( const_cast<const UntypedMemberExpr *>(node) ); }
+        virtual void visit( const UntypedMemberExpr * memberExpr ) = 0;
+        virtual void visit( MemberExpr * node ) { visit( const_cast<const MemberExpr *>(node) ); }
+        virtual void visit( const MemberExpr * memberExpr ) = 0;
+        virtual void visit( VariableExpr * node ) { visit( const_cast<const VariableExpr *>(node) ); }
+        virtual void visit( const VariableExpr * variableExpr ) = 0;
+        virtual void visit( ConstantExpr * node ) { visit( const_cast<const ConstantExpr *>(node) ); }
+        virtual void visit( const ConstantExpr * constantExpr ) = 0;
+        virtual void visit( SizeofExpr * node ) { visit( const_cast<const SizeofExpr *>(node) ); }
+        virtual void visit( const SizeofExpr * sizeofExpr ) = 0;
+        virtual void visit( AlignofExpr * node ) { visit( const_cast<const AlignofExpr *>(node) ); }
+        virtual void visit( const AlignofExpr * alignofExpr ) = 0;
+        virtual void visit( UntypedOffsetofExpr * node ) { visit( const_cast<const UntypedOffsetofExpr *>(node) ); }
+        virtual void visit( const UntypedOffsetofExpr * offsetofExpr ) = 0;
+        virtual void visit( OffsetofExpr * node ) { visit( const_cast<const OffsetofExpr *>(node) ); }
+        virtual void visit( const OffsetofExpr * offsetofExpr ) = 0;
+        virtual void visit( OffsetPackExpr * node ) { visit( const_cast<const OffsetPackExpr *>(node) ); }
+        virtual void visit( const OffsetPackExpr * offsetPackExpr ) = 0;
+        virtual void visit( LogicalExpr * node ) { visit( const_cast<const LogicalExpr *>(node) ); }
+        virtual void visit( const LogicalExpr * logicalExpr ) = 0;
+        virtual void visit( ConditionalExpr * node ) { visit( const_cast<const ConditionalExpr *>(node) ); }
+        virtual void visit( const ConditionalExpr * conditionalExpr ) = 0;
+        virtual void visit( CommaExpr * node ) { visit( const_cast<const CommaExpr *>(node) ); }
+        virtual void visit( const CommaExpr * commaExpr ) = 0;
+        virtual void visit( TypeExpr * node ) { visit( const_cast<const TypeExpr *>(node) ); }
+        virtual void visit( const TypeExpr * typeExpr ) = 0;
+        virtual void visit( AsmExpr * node ) { visit( const_cast<const AsmExpr *>(node) ); }
+        virtual void visit( const AsmExpr * asmExpr ) = 0;
+        virtual void visit( ImplicitCopyCtorExpr * node ) { visit( const_cast<const ImplicitCopyCtorExpr *>(node) ); }
+        virtual void visit( const ImplicitCopyCtorExpr * impCpCtorExpr ) = 0;
+        virtual void visit( ConstructorExpr * node ) { visit( const_cast<const ConstructorExpr *>(node) ); }
+        virtual void visit( const ConstructorExpr *  ctorExpr ) = 0;
+        virtual void visit( CompoundLiteralExpr * node ) { visit( const_cast<const CompoundLiteralExpr *>(node) ); }
+        virtual void visit( const CompoundLiteralExpr * compLitExpr ) = 0;
+        virtual void visit( RangeExpr * node ) { visit( const_cast<const RangeExpr *>(node) ); }
+        virtual void visit( const RangeExpr * rangeExpr ) = 0;
+        virtual void visit( UntypedTupleExpr * node ) { visit( const_cast<const UntypedTupleExpr *>(node) ); }
+        virtual void visit( const UntypedTupleExpr * tupleExpr ) = 0;
+        virtual void visit( TupleExpr * node ) { visit( const_cast<const TupleExpr *>(node) ); }
+        virtual void visit( const TupleExpr * tupleExpr ) = 0;
+        virtual void visit( TupleIndexExpr * node ) { visit( const_cast<const TupleIndexExpr *>(node) ); }
+        virtual void visit( const TupleIndexExpr * tupleExpr ) = 0;
+        virtual void visit( TupleAssignExpr * node ) { visit( const_cast<const TupleAssignExpr *>(node) ); }
+        virtual void visit( const TupleAssignExpr * assignExpr ) = 0;
+        virtual void visit( StmtExpr * node ) { visit( const_cast<const StmtExpr *>(node) ); }
+        virtual void visit( const StmtExpr *  stmtExpr ) = 0;
+        virtual void visit( UniqueExpr * node ) { visit( const_cast<const UniqueExpr *>(node) ); }
+        virtual void visit( const UniqueExpr *  uniqueExpr ) = 0;
+        virtual void visit( UntypedInitExpr * node ) { visit( const_cast<const UntypedInitExpr *>(node) ); }
+        virtual void visit( const UntypedInitExpr *  initExpr ) = 0;
+        virtual void visit( InitExpr * node ) { visit( const_cast<const InitExpr *>(node) ); }
+        virtual void visit( const InitExpr *  initExpr ) = 0;
+        virtual void visit( DeletedExpr * node ) { visit( const_cast<const DeletedExpr *>(node) ); }
+        virtual void visit( const DeletedExpr * delExpr ) = 0;
+        virtual void visit( DefaultArgExpr * node ) { visit( const_cast<const DefaultArgExpr *>(node) ); }
+        virtual void visit( const DefaultArgExpr * argExpr ) = 0;
+        virtual void visit( GenericExpr * node ) { visit( const_cast<const GenericExpr *>(node) ); }
+        virtual void visit( const GenericExpr * genExpr ) = 0;
+
+        virtual void visit( VoidType * node ) { visit( const_cast<const VoidType *>(node) ); }
+        virtual void visit( const VoidType * basicType ) = 0;
+        virtual void visit( BasicType * node ) { visit( const_cast<const BasicType *>(node) ); }
+        virtual void visit( const BasicType * basicType ) = 0;
+        virtual void visit( PointerType * node ) { visit( const_cast<const PointerType *>(node) ); }
+        virtual void visit( const PointerType * pointerType ) = 0;
+        virtual void visit( ArrayType * node ) { visit( const_cast<const ArrayType *>(node) ); }
+        virtual void visit( const ArrayType * arrayType ) = 0;
+        virtual void visit( ReferenceType * node ) { visit( const_cast<const ReferenceType *>(node) ); }
+        virtual void visit( const ReferenceType * refType ) = 0;
+        virtual void visit( QualifiedType * node ) { visit( const_cast<const QualifiedType *>(node) ); }
+        virtual void visit( const QualifiedType * qualType ) = 0;
+        virtual void visit( FunctionType * node ) { visit( const_cast<const FunctionType *>(node) ); }
+        virtual void visit( const FunctionType * functionType ) = 0;
+        virtual void visit( StructInstType * node ) { visit( const_cast<const StructInstType *>(node) ); }
+        virtual void visit( const StructInstType * aggregateUseType ) = 0;
+        virtual void visit( UnionInstType * node ) { visit( const_cast<const UnionInstType *>(node) ); }
+        virtual void visit( const UnionInstType * aggregateUseType ) = 0;
+        virtual void visit( EnumInstType * node ) { visit( const_cast<const EnumInstType *>(node) ); }
+        virtual void visit( const EnumInstType * aggregateUseType ) = 0;
+        virtual void visit( TraitInstType * node ) { visit( const_cast<const TraitInstType *>(node) ); }
+        virtual void visit( const TraitInstType * aggregateUseType ) = 0;
+        virtual void visit( TypeInstType * node ) { visit( const_cast<const TypeInstType *>(node) ); }
+        virtual void visit( const TypeInstType * aggregateUseType ) = 0;
+        virtual void visit( TupleType * node ) { visit( const_cast<const TupleType *>(node) ); }
+        virtual void visit( const TupleType * tupleType ) = 0;
+        virtual void visit( TypeofType * node ) { visit( const_cast<const TypeofType *>(node) ); }
+        virtual void visit( const TypeofType * typeofType ) = 0;
+        virtual void visit( AttrType * node ) { visit( const_cast<const AttrType *>(node) ); }
+        virtual void visit( const AttrType * attrType ) = 0;
+        virtual void visit( VarArgsType * node ) { visit( const_cast<const VarArgsType *>(node) ); }
+        virtual void visit( const VarArgsType * varArgsType ) = 0;
+        virtual void visit( ZeroType * node ) { visit( const_cast<const ZeroType *>(node) ); }
+        virtual void visit( const ZeroType * zeroType ) = 0;
+        virtual void visit( OneType * node ) { visit( const_cast<const OneType *>(node) ); }
+        virtual void visit( const OneType * oneType ) = 0;
+        virtual void visit( GlobalScopeType * node ) { visit( const_cast<const GlobalScopeType *>(node) ); }
+        virtual void visit( const GlobalScopeType * globalType ) = 0;
+
+        virtual void visit( Designation * node ) { visit( const_cast<const Designation *>(node) ); }
+        virtual void visit( const Designation * designation ) = 0;
+        virtual void visit( SingleInit * node ) { visit( const_cast<const SingleInit *>(node) ); }
+        virtual void visit( const SingleInit * singleInit ) = 0;
+        virtual void visit( ListInit * node ) { visit( const_cast<const ListInit *>(node) ); }
+        virtual void visit( const ListInit * listInit ) = 0;
+        virtual void visit( ConstructorInit * node ) { visit( const_cast<const ConstructorInit *>(node) ); }
+        virtual void visit( const ConstructorInit * ctorInit ) = 0;
+
+        virtual void visit( Constant * node ) { visit( const_cast<const Constant *>(node) ); }
+        virtual void visit( const Constant * constant ) = 0;
+
+        virtual void visit( Attribute * node ) { visit( const_cast<const Attribute *>(node) ); }
+        virtual void visit( const Attribute * attribute ) = 0;
 };
 
 template< typename TreeType, typename VisitorType >
-inline void maybeAccept( TreeType *tree, VisitorType &visitor ) {
+inline void maybeAccept( TreeType * tree, VisitorType & visitor ) {
         if ( tree ) {
                 tree->accept( visitor );
@@ -134 +226 @@
 }
 
+template< typename TreeType, typename VisitorType >
+inline void maybeAccept( const TreeType * tree, VisitorType & visitor ) {
+        if ( tree ) {
+                tree->accept( visitor );
+        }
+}
+
 template< typename Container, typename VisitorType >
-inline void acceptAll( Container &container, VisitorType &visitor ) {
+inline void acceptAll( Container & container, VisitorType & visitor ) {
         SemanticErrorException errors;
-        for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
+        for ( auto * i : container ) {
                 try {
-                        if ( *i ) {
-                                (*i)->accept( visitor );
+                        if ( i ) {
+                                i->accept( visitor );
+                        }
+                } catch( SemanticErrorException & e ) {
+                        errors.append( e );
+                }
+        }
+        if ( ! errors.isEmpty() ) {
+                throw errors;
+        }
+}
+
+template< typename Container, typename VisitorType >
+inline void acceptAll( const Container & container, VisitorType & visitor ) {
+        SemanticErrorException errors;
+        for ( const auto * i : container ) {
+                try {
+                        if ( i ) {
+                                i->accept( visitor );
                         }
                 } catch( SemanticErrorException &e ) {

src/SynTree/module.mk

@@ -15 +15 @@
 ###############################################################################
 
-SRC += SynTree/Type.cc \
-       SynTree/VoidType.cc \
-       SynTree/BasicType.cc \
-       SynTree/PointerType.cc \
-       SynTree/ArrayType.cc \
-       SynTree/ReferenceType.cc \
-       SynTree/FunctionType.cc \
-       SynTree/ReferenceToType.cc \
-       SynTree/TupleType.cc \
-       SynTree/TypeofType.cc \
-       SynTree/AttrType.cc \
-       SynTree/VarArgsType.cc \
-       SynTree/ZeroOneType.cc \
-       SynTree/Constant.cc \
-       SynTree/Expression.cc \
-       SynTree/TupleExpr.cc \
-       SynTree/CommaExpr.cc \
-       SynTree/TypeExpr.cc \
-       SynTree/ApplicationExpr.cc \
-       SynTree/AddressExpr.cc \
-       SynTree/Statement.cc \
-       SynTree/CompoundStmt.cc \
-       SynTree/DeclStmt.cc \
-       SynTree/Declaration.cc \
-       SynTree/DeclarationWithType.cc \
-       SynTree/ObjectDecl.cc \
-       SynTree/FunctionDecl.cc \
-       SynTree/AggregateDecl.cc \
-       SynTree/NamedTypeDecl.cc \
-       SynTree/TypeDecl.cc \
-       SynTree/Initializer.cc \
-       SynTree/TypeSubstitution.cc \
-       SynTree/Attribute.cc \
-       SynTree/DeclReplacer.cc
+SRC_SYNTREE = \
+      SynTree/Type.cc \
+      SynTree/VoidType.cc \
+      SynTree/BasicType.cc \
+      SynTree/PointerType.cc \
+      SynTree/ArrayType.cc \
+      SynTree/ReferenceType.cc \
+      SynTree/FunctionType.cc \
+      SynTree/ReferenceToType.cc \
+      SynTree/TupleType.cc \
+      SynTree/TypeofType.cc \
+      SynTree/AttrType.cc \
+      SynTree/VarArgsType.cc \
+      SynTree/ZeroOneType.cc \
+      SynTree/Constant.cc \
+      SynTree/Expression.cc \
+      SynTree/TupleExpr.cc \
+      SynTree/CommaExpr.cc \
+      SynTree/TypeExpr.cc \
+      SynTree/ApplicationExpr.cc \
+      SynTree/AddressExpr.cc \
+      SynTree/Statement.cc \
+      SynTree/CompoundStmt.cc \
+      SynTree/DeclStmt.cc \
+      SynTree/Declaration.cc \
+      SynTree/DeclarationWithType.cc \
+      SynTree/ObjectDecl.cc \
+      SynTree/FunctionDecl.cc \
+      SynTree/AggregateDecl.cc \
+      SynTree/NamedTypeDecl.cc \
+      SynTree/TypeDecl.cc \
+      SynTree/Initializer.cc \
+      SynTree/TypeSubstitution.cc \
+      SynTree/Attribute.cc \
+      SynTree/DeclReplacer.cc
 
+SRC += $(SRC_SYNTREE)
+SRCDEMANGLE += $(SRC_SYNTREE)