Changeset 90152a4 for src/SynTree

Timestamp:

Aug 27, 2018, 4:40:34 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

b7c89aa

Parents:

f9feab8 (diff), 305581d (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' into cleanup-dtors

Location:

src/SynTree

Files:

• AggregateDecl.cc (modified) (1 diff)
• ApplicationExpr.cc (modified) (1 diff)
• Attribute.cc (modified) (2 diffs)
• Attribute.h (modified) (1 diff)
• BasicType.cc (modified) (1 diff)
• CompoundStmt.cc (modified) (3 diffs)
• DeclReplacer.cc (added)
• DeclReplacer.h (added)
• Declaration.cc (modified) (1 diff)
• Declaration.h (modified) (7 diffs)
• Expression.cc (modified) (10 diffs)
• Expression.h (modified) (7 diffs)
• FunctionDecl.cc (modified) (3 diffs)
• Label.h (modified) (1 diff)
• Mutator.cc (deleted)
• Mutator.h (modified) (3 diffs)
• ReferenceToType.cc (modified) (7 diffs)
• ReferenceType.cc (modified) (2 diffs)
• Statement.cc (modified) (8 diffs)
• Statement.h (modified) (6 diffs)
• SynTree.h (modified) (6 diffs)
• Type.cc (modified) (5 diffs)
• Type.h (modified) (9 diffs)
• TypeSubstitution.cc (modified) (2 diffs)
• TypeSubstitution.h (modified) (7 diffs)
• VarExprReplacer.cc (deleted)
• VarExprReplacer.h (deleted)
• Visitor.cc (deleted)
• Visitor.h (modified) (3 diffs)
• module.mk (modified) (1 diff)

src/SynTree/AggregateDecl.cc

@@ -86 +86 @@
 std::string TraitDecl::typeString() const { return "trait"; }
 
+bool EnumDecl::valueOf( Declaration * enumerator, long long int & value ) {
+        if ( enumValues.empty() ) {
+                long long int currentValue = 0;
+                for ( Declaration * member : members ) {
+                        ObjectDecl * field = strict_dynamic_cast< ObjectDecl * >( member );
+                        if ( field->init ) {
+                                SingleInit * init = strict_dynamic_cast< SingleInit * >( field->init );
+                                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() );
+                        enumValues[ field->name ] = currentValue;
+                        ++currentValue;
+                }
+        }
+        if ( enumValues.count( enumerator->name ) ) {
+                value = enumValues[ enumerator->name ];
+                return true;
+        }
+        return false;
+}
+
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/ApplicationExpr.cc

@@ -49 +49 @@
 }
 
+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;
+}
+
+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 );
+        return *this;
+}
+
 ApplicationExpr::ApplicationExpr( Expression *funcExpr, const std::list<Expression *> & args ) : function( funcExpr ), args( args ) {
         PointerType *pointer = strict_dynamic_cast< PointerType* >( funcExpr->get_result() );

src/SynTree/Attribute.cc

@@ -15 +15 @@
 
 #include <ostream>           // for operator<<, ostream, basic_ostream, endl
+#include <set>
 
 #include "Attribute.h"
@@ -21 +22 @@
 
 Attribute::Attribute( const Attribute &other ) : name( other.name ) {
-  cloneAll( other.parameters, parameters );
+        cloneAll( other.parameters, parameters );
 }
 
 Attribute::~Attribute() {
-  deleteAll( parameters );
+        deleteAll( parameters );
+}
+
+bool Attribute::isValidOnFuncParam() const {
+        // attributes such as aligned, cleanup, etc. produce GCC errors when they appear
+        // on function parameters. Maintain here a whitelist of attribute names that are
+        // allowed to appear on parameters.
+        static std::set< std::string > valid = {
+                "noreturn", "unused"
+        };
+        return valid.count( normalizedName() );
+}
+
+std::string Attribute::normalizedName() const {
+        // trim beginning/ending _, convert to lowercase
+        auto begin = name.find_first_not_of('_');
+        auto end = name.find_last_not_of('_');
+        if (begin == std::string::npos || end == std::string::npos) return "";
+        std::string ret;
+        ret.reserve( end-begin+1 );
+        std::transform( &name[begin], &name[end+1], back_inserter( ret ), tolower );
+        return ret;
 }
 
 void Attribute::print( std::ostream &os, Indenter indent ) const {
-  using std::endl;
-  using std::string;
+        using std::endl;
+        using std::string;
 
-  if ( ! empty() ) {
-    os << "Attribute with name: " << name;
-    if ( ! parameters.empty() ) {
-      os << " with parameters: " << endl;
-      printAll( parameters, os, indent+1 );
-    }
-  }
+        if ( ! empty() ) {
+                os << "Attribute with name: " << name;
+                if ( ! parameters.empty() ) {
+                        os << " with parameters: " << endl;
+                        printAll( parameters, os, indent+1 );
+                }
+        }
 }
 

src/SynTree/Attribute.h

@@ -43 +43 @@
         bool empty() const { return name == ""; }
 
+        std::string normalizedName() const;
+
+        /// true if this attribute is allowed to appear attached to a function parameter
+        bool isValidOnFuncParam() const;
+
         Attribute * clone() const override { return new Attribute( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }

src/SynTree/BasicType.cc

@@ -55 +55 @@
           case DoubleImaginary:
           case LongDoubleImaginary:
+          case Float80:
+          case Float128:
                 return false;
           case NUMBER_OF_BASIC_TYPES:

src/SynTree/CompoundStmt.cc

@@ -23 +23 @@
 #include "Statement.h"                // for CompoundStmt, Statement, DeclStmt
 #include "SynTree/Label.h"            // for Label
-#include "SynTree/VarExprReplacer.h"  // for VarExprReplacer, VarExprReplace...
+#include "SynTree/DeclReplacer.h"     // for DeclReplacer
 
 using std::string;
@@ -49 +49 @@
         // recursively execute this routine. There may be more efficient ways of doing
         // this.
-        VarExprReplacer::DeclMap declMap;
+        DeclReplacer::DeclMap declMap;
         std::list< Statement * >::const_iterator origit = other.kids.begin();
         for ( Statement * s : kids ) {
@@ -59 +59 @@
                                 DeclarationWithType * origdwt = strict_dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() );
                                 assert( dwt->get_name() == origdwt->get_name() );
-                                declMap[ origdwt ] = new VariableExpr( dwt );
+                                declMap[ origdwt ] = dwt;
                         } else assert( ! dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() ) );
                 } else assert( ! dynamic_cast< DeclStmt * > ( s ) );
         }
         if ( ! declMap.empty() ) {
-                VarExprReplacer replacer( declMap );
-                acceptMutator( replacer );
+                DeclReplacer::replace( this, declMap );
         }
 }

src/SynTree/Declaration.cc

@@ -81 +81 @@
 
 
+StaticAssertDecl::StaticAssertDecl( Expression * condition, ConstantExpr * message ) : Declaration( "", Type::StorageClasses(), LinkageSpec::C ), condition( condition ), message( message )  {
+}
+
+StaticAssertDecl::StaticAssertDecl( const StaticAssertDecl & other ) : Declaration( other ), condition( maybeClone( other.condition ) ), message( maybeClone( other.message ) )  {
+}
+
+StaticAssertDecl::~StaticAssertDecl() {
+        delete condition;
+        delete message;
+}
+
+void StaticAssertDecl::print( std::ostream &os, Indenter indent ) const {
+        os << "Static Assert with condition: ";
+        condition->print( os, indent+1 );
+        os << std::endl << indent << "and message: ";
+        message->print( os, indent+1 );
+os << std::endl;
+}
+
+void StaticAssertDecl::printShort( std::ostream &os, Indenter indent ) const {
+        print( os, indent );
+}
+
+
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Declaration.h

@@ -84 +84 @@
         Expression *asmName;
         std::list< Attribute * > attributes;
+        bool isDeleted = false;
 
         DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
@@ -151 +152 @@
         FunctionType *type;
         CompoundStmt *statements;
+        std::list< Expression * > withExprs;
 
         FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements,
@@ -200 +202 @@
         typedef NamedTypeDecl Parent;
   public:
-        enum Kind { Dtype, Ftype, Ttype };
+        enum Kind { Dtype, Ftype, Ttype, NUMBER_OF_KINDS };
 
         Type * init;
@@ -244 +246 @@
         typedef NamedTypeDecl Parent;
   public:
-        TypedefDecl( const std::string &name, Type::StorageClasses scs, Type *type, LinkageSpec::Spec spec = LinkageSpec::Cforall ) : Parent( name, scs, type ) { set_linkage( spec ); }
+        TypedefDecl( const std::string &name, CodeLocation location, Type::StorageClasses scs, Type *type, LinkageSpec::Spec spec = LinkageSpec::Cforall )
+                : Parent( name, scs, type ) { set_linkage( spec ); this->location = location; }
+
         TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
 
@@ -262 +266 @@
         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 );
@@ -319 +324 @@
         EnumDecl( const EnumDecl &other ) : Parent( other ) {}
 
+        bool valueOf( Declaration * enumerator, long long int & value );
+
         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 std::string typeString() const override;
 };
@@ -355 +363 @@
         virtual void accept( Visitor &v ) override { v.visit( this ); }
         virtual AsmDecl *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;
+};
+
+class StaticAssertDecl : public Declaration {
+public:
+        Expression * condition;
+        ConstantExpr * message;   // string literal
+
+        StaticAssertDecl( Expression * condition, ConstantExpr * message );
+        StaticAssertDecl( const StaticAssertDecl & other );
+        virtual ~StaticAssertDecl();
+
+        virtual StaticAssertDecl * clone() const override { return new StaticAssertDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual StaticAssertDecl * 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;

src/SynTree/Expression.cc

@@ -50 +50 @@
 }
 
+void Expression::spliceInferParams( Expression * other ) {
+        if ( ! other ) return;
+        for ( auto p : other->inferParams ) {
+                inferParams[p.first] = std::move( p.second );
+        }
+}
+
 Expression::~Expression() {
         delete env;
@@ -81 +88 @@
         constant.print( os );
         Expression::print( os, indent );
+}
+
+long long int ConstantExpr::intValue() const {
+        if ( BasicType * basicType = dynamic_cast< BasicType * >( result ) ) {
+                if ( basicType->isInteger() ) {
+                        return get_constant()->get_ival();
+                }
+        } else if ( dynamic_cast< OneType * >( result ) ) {
+                return 1;
+        } else if ( dynamic_cast< ZeroType * >( result ) ) {
+                return 0;
+        }
+        SemanticError( this, "Constant expression of non-integral type " );
 }
 
@@ -95 +115 @@
         //      assert( inst->baseEnum );
         //      EnumDecl * decl = inst->baseEnum;
-        //      for ( Declaration * member : decl->members ) {
-        //              if ( member == _var ) {
-        //                      type->set_lvalue( false );
-        //              }
+        //      long long int value;
+        //      if ( decl->valueOf( var, value ) ) {
+        //              type->set_lvalue( false );
         //      }
         // }
@@ -259 +278 @@
 }
 
-CastExpr::CastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
+CastExpr::CastExpr( Expression *arg, Type *toType, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
         set_result(toType);
 }
 
-CastExpr::CastExpr( Expression *arg_ ) : Expression(), arg(arg_) {
+CastExpr::CastExpr( Expression *arg, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
         set_result( new VoidType( Type::Qualifiers() ) );
 }
 
-CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
+CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
 }
 
@@ -287 +306 @@
 }
 
+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() {
+        delete arg;
+}
+
+const std::string & KeywordCastExpr::targetString() const {
+        static const std::string targetStrs[] = {
+                "coroutine", "thread", "monitor"
+        };
+        static_assert(
+                (sizeof(targetStrs) / sizeof(targetStrs[0])) == ((unsigned long)NUMBER_OF_TARGETS),
+                "Each KeywordCastExpr::Target should have a corresponding string representation"
+        );
+        return targetStrs[(unsigned long)target];
+}
+
+void KeywordCastExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Keyword Cast of:" << std::endl << indent+1;
+        arg->print(os, indent+1);
+        os << std::endl << indent << "... to: ";
+        os << targetString();
+        Expression::print( os, indent );
+}
+
 VirtualCastExpr::VirtualCastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
         set_result(toType);
@@ -333 +381 @@
 }
 
-namespace {
-        TypeSubstitution makeSub( Type * t ) {
-                if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( t ) ) {
-                        return makeSub( refType->get_base() );
-                } else if ( StructInstType * aggInst = dynamic_cast< StructInstType * >( t ) ) {
-                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->parameters.begin() );
-                } else if ( UnionInstType * aggInst = dynamic_cast< UnionInstType * >( t ) ) {
-                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->parameters.begin() );
-                } else {
-                        assertf( false, "makeSub expects struct or union type for aggregate, but got: %s", toString( t ).c_str() );
-                }
-        }
-}
-
-
 MemberExpr::MemberExpr( DeclarationWithType *member, Expression *aggregate ) :
                 Expression(), member(member), aggregate(aggregate) {
         assert( member );
         assert( aggregate );
-
-        TypeSubstitution sub( makeSub( aggregate->get_result() ) );
+        assert( aggregate->result );
+
+        TypeSubstitution sub = aggregate->result->genericSubstitution();
         Type * res = member->get_type()->clone();
         sub.apply( res );
@@ -403 +437 @@
                 } else {
                         // references have been removed, in which case dereference returns an lvalue of the base type.
-                        ret->get_result()->set_lvalue( true );
+                        ret->result->set_lvalue( true );
                 }
         }
@@ -585 +619 @@
 
 StmtExpr::StmtExpr( CompoundStmt *statements ) : statements( statements ) {
-        assert( statements );
-        std::list< Statement * > & body = statements->get_kids();
-        if ( ! body.empty() ) {
-                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( body.back() ) ) {
-                        set_result( maybeClone( exprStmt->get_expr()->get_result() ) );
-                }
-        }
-        // ensure that StmtExpr has a result type
-        if ( ! result ) {
-                set_result( new VoidType( Type::Qualifiers() ) );
-        }
+        computeResult();
 }
 StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) {
@@ -605 +629 @@
         deleteAll( dtors );
         deleteAll( returnDecls );
+}
+void StmtExpr::computeResult() {
+        assert( statements );
+        std::list< Statement * > & body = statements->kids;
+        delete result;
+        result = nullptr;
+        if ( ! returnDecls.empty() ) {
+                // prioritize return decl for result type, since if a return decl exists, then
+                // the StmtExpr is currently in an intermediate state where the body will always
+                // give a void result type.
+                result = returnDecls.front()->get_type()->clone();
+        } else if ( ! body.empty() ) {
+                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( body.back() ) ) {
+                        result = maybeClone( exprStmt->expr->result );
+                }
+        }
+        // ensure that StmtExpr has a result type
+        if ( ! result ) {
+                result = new VoidType( Type::Qualifiers() );
+        }
 }
 void StmtExpr::print( std::ostream &os, Indenter indent ) const {
@@ -688 +732 @@
 }
 
+DeletedExpr::DeletedExpr( Expression * expr, BaseSyntaxNode * deleteStmt ) : expr( expr ), deleteStmt( deleteStmt ) {
+        assert( expr->result );
+        result = expr->result->clone();
+}
+DeletedExpr::DeletedExpr( const DeletedExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), deleteStmt( other.deleteStmt ) {}
+DeletedExpr::~DeletedExpr() {
+        delete expr;
+}
+
+void DeletedExpr::print( std::ostream & os, Indenter indent ) const {
+        os << "Deleted Expression" << std::endl << indent+1;
+        expr->print( os, indent+1 );
+        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 );
+}
+
+GenericExpr::Association::Association( Type * type, Expression * expr ) : type( type ), expr( expr ), isDefault( false ) {}
+GenericExpr::Association::Association( Expression * expr ) : type( nullptr ), expr( expr ), isDefault( true ) {}
+GenericExpr::Association::Association( const Association & other ) : type( maybeClone( other.type ) ), expr( maybeClone( other.expr ) ), isDefault( other.isDefault ) {}
+GenericExpr::Association::~Association() {
+        delete type;
+        delete expr;
+}
+
+GenericExpr::GenericExpr( Expression * control, const std::list<Association> & assoc ) : Expression(), control( control ), associations( assoc ) {}
+GenericExpr::GenericExpr( const GenericExpr & other ) : Expression(other), control( maybeClone( other.control ) ), associations( other.associations ) {
+}
+GenericExpr::~GenericExpr() {
+        delete control;
+}
+
+void GenericExpr::print( std::ostream & os, Indenter indent ) const {
+        os << "C11 _Generic Expression" << std::endl << indent+1;
+        control->print( os, indent+1 );
+        os << std::endl << indent+1 << "... with associations: " << std::endl;
+        for ( const Association & assoc : associations ) {
+                os << indent+1;
+                if (assoc.isDefault) {
+                        os << "... default: ";
+                        assoc.expr->print( os, indent+1 );
+                } else {
+                        os << "... type: ";
+                        assoc.type->print( os, indent+1 );
+                        os << std::endl << indent+1 << "... expression: ";
+                        assoc.expr->print( os, indent+1 );
+                        os << std::endl;
+                }
+                os << std::endl;
+        }
+}
+
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Expression.h

@@ -41 +41 @@
         ParamEntry( UniqueId decl, Type * actualType, Type * formalType, Expression* expr ): decl( decl ), actualType( actualType ), formalType( formalType ), expr( expr ), inferParams( new InferredParams ) {}
         ParamEntry( const ParamEntry & other );
+        ParamEntry( ParamEntry && other );
         ~ParamEntry();
         ParamEntry & operator=( const ParamEntry & other );
+        ParamEntry & operator=( ParamEntry && other );
 
         UniqueId decl;
@@ -74 +76 @@
         InferredParams & get_inferParams() { return inferParams; }
 
+        // move other's inferParams to this
+        void spliceInferParams( Expression * other );
+
         virtual Expression * clone() const override = 0;
         virtual void accept( Visitor & v ) override = 0;
@@ -188 +193 @@
   public:
         Expression * arg;
-
-        CastExpr( Expression * arg );
-        CastExpr( Expression * arg, Type * toType );
+        bool isGenerated = true; // whether this cast appeared in the source program
+
+        CastExpr( Expression * arg, bool isGenerated = true );
+        CastExpr( Expression * arg, Type * toType, bool isGenerated = true );
+        CastExpr( Expression * arg, void * ) = delete; // prevent accidentally passing pointers for isGenerated in the first constructor
         CastExpr( const CastExpr & other );
         virtual ~CastExpr();
@@ -198 +205 @@
 
         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;
+};
+
+/// KeywordCastExpr represents a cast to 'keyword types', e.g. (thread &)t
+class KeywordCastExpr : public Expression {
+public:
+        Expression * arg;
+        enum Target {
+                Coroutine, Thread, Monitor, NUMBER_OF_TARGETS
+        } target;
+
+        KeywordCastExpr( Expression * arg, Target target );
+        KeywordCastExpr( const KeywordCastExpr & other );
+        virtual ~KeywordCastExpr();
+
+        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 ); }
@@ -295 +322 @@
 
         Constant * get_constant() { return & constant; }
+        const Constant * get_constant() const { return & constant; }
         void set_constant( const Constant & newValue ) { constant = newValue; }
+
+        long long int intValue() const;
 
         virtual ConstantExpr * clone() const { return new ConstantExpr( * this ); }
@@ -725 +755 @@
         StmtExpr * set_statements( CompoundStmt * newValue ) { statements = newValue; return this; }
 
+        // call to set the result type of this StmtExpr based on its body
+        void computeResult();
+
         std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
         std::list< Expression * > & get_dtors() { return dtors; }
@@ -816 +849 @@
 };
 
+/// expression that contains a deleted identifier - should never make it past the resolver.
+class DeletedExpr : public Expression {
+public:
+        Expression * expr;
+        BaseSyntaxNode * deleteStmt;
+
+        DeletedExpr( Expression * expr, BaseSyntaxNode * 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;
+};
+
+/// 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 { return new DefaultArgExpr( * 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;
+};
+
+/// C11 _Generic expression
+class GenericExpr : public Expression {
+public:
+        struct Association {
+                Type * type = nullptr;
+                Expression * expr = nullptr;
+                bool isDefault = false;
+
+                Association( Type * type, Expression * expr );
+                Association( Expression * expr );
+                Association( const Association & other );
+                Association & operator=( const Association & other ) = delete; // at the moment this isn't used, and I don't want to implement it
+                ~Association();
+        };
+
+        Expression * control;
+        std::list<Association> associations;
+
+        GenericExpr( Expression * control, const std::list<Association> & assoc );
+        GenericExpr( const GenericExpr & other );
+        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;
+};
+
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/FunctionDecl.cc

@@ -26 +26 @@
 #include "Statement.h"           // for CompoundStmt
 #include "Type.h"                // for Type, FunctionType, Type::FuncSpecif...
-#include "VarExprReplacer.h"
+#include "DeclReplacer.h"
 
 extern bool translation_unit_nomain;
@@ -41 +41 @@
                 : Parent( other ), type( maybeClone( other.type ) ), statements( maybeClone( other.statements ) ) {
 
-        VarExprReplacer::DeclMap declMap;
+        DeclReplacer::DeclMap declMap;
         for ( auto p : group_iterate( other.type->parameters, type->parameters ) ) {
-                declMap[ std::get<0>(p) ] = new VariableExpr( std::get<1>(p) );
+                declMap[ std::get<0>(p) ] = std::get<1>(p);
         }
         for ( auto p : group_iterate( other.type->returnVals, type->returnVals ) ) {
-                declMap[ std::get<0>(p) ] = new VariableExpr( std::get<1>(p) );
+                declMap[ std::get<0>(p) ] = std::get<1>(p);
         }
         if ( ! declMap.empty() ) {
-                VarExprReplacer replacer( declMap );
-                acceptMutator( replacer );
+                DeclReplacer::replace( this, declMap );
         }
+        cloneAll( other.withExprs, withExprs );
 }
 
@@ -57 +57 @@
         delete type;
         delete statements;
+        deleteAll( withExprs );
 }
 

src/SynTree/Label.h

@@ -33 +33 @@
         std::list< Attribute * >& get_attributes() { return attributes; }
 
-        operator std::string() { return name; }
+        operator std::string() const { return name; }
         bool empty() { return name.empty(); }
   private:

src/SynTree/Mutator.h

@@ -22 +22 @@
 class Mutator {
   protected:
-        Mutator();
-        virtual ~Mutator();
+        Mutator() = default;
+        virtual ~Mutator() = default;
   public:
-        virtual DeclarationWithType * mutate( ObjectDecl * objectDecl );
-        virtual DeclarationWithType * mutate( FunctionDecl * functionDecl );
-        virtual Declaration * mutate( StructDecl * aggregateDecl );
-        virtual Declaration * mutate( UnionDecl * aggregateDecl );
-        virtual Declaration * mutate( EnumDecl * aggregateDecl );
-        virtual Declaration * mutate( TraitDecl * aggregateDecl );
-        virtual Declaration * mutate( TypeDecl * typeDecl );
-        virtual Declaration * mutate( TypedefDecl * typeDecl );
-        virtual AsmDecl * mutate( AsmDecl * asmDecl );
+        virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ) = 0;
+        virtual DeclarationWithType * mutate( FunctionDecl * functionDecl ) = 0;
+        virtual Declaration * mutate( StructDecl * aggregateDecl ) = 0;
+        virtual Declaration * mutate( UnionDecl * aggregateDecl ) = 0;
+        virtual Declaration * mutate( EnumDecl * aggregateDecl ) = 0;
+        virtual Declaration * mutate( TraitDecl * aggregateDecl ) = 0;
+        virtual Declaration * mutate( TypeDecl * typeDecl ) = 0;
+        virtual Declaration * mutate( TypedefDecl * typeDecl ) = 0;
+        virtual AsmDecl * mutate( AsmDecl * asmDecl ) = 0;
+        virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) = 0;
 
-        virtual CompoundStmt * mutate( CompoundStmt * compoundStmt );
-        virtual Statement * mutate( ExprStmt * exprStmt );
-        virtual Statement * mutate( AsmStmt * asmStmt );
-        virtual Statement * mutate( IfStmt * ifStmt );
-        virtual Statement * mutate( WhileStmt * whileStmt );
-        virtual Statement * mutate( ForStmt * forStmt );
-        virtual Statement * mutate( SwitchStmt * switchStmt );
-        virtual Statement * mutate( CaseStmt * caseStmt );
-        virtual Statement * mutate( BranchStmt * branchStmt );
-        virtual Statement * mutate( ReturnStmt * returnStmt );
-        virtual Statement * mutate( ThrowStmt * throwStmt );
-        virtual Statement * mutate( TryStmt * tryStmt );
-        virtual Statement * mutate( CatchStmt * catchStmt );
-        virtual Statement * mutate( FinallyStmt * catchStmt );
-        virtual Statement * mutate( WaitForStmt * waitforStmt );
-        virtual Statement * mutate( WithStmt * withStmt );
-        virtual NullStmt * mutate( NullStmt * nullStmt );
-        virtual Statement * mutate( DeclStmt * declStmt );
-        virtual Statement * mutate( ImplicitCtorDtorStmt * impCtorDtorStmt );
+        virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) = 0;
+        virtual Statement * mutate( ExprStmt * exprStmt ) = 0;
+        virtual Statement * mutate( AsmStmt * asmStmt ) = 0;
+        virtual Statement * mutate( DirectiveStmt * dirStmt ) = 0;
+        virtual Statement * mutate( IfStmt * ifStmt ) = 0;
+        virtual Statement * mutate( WhileStmt * whileStmt ) = 0;
+        virtual Statement * mutate( ForStmt * forStmt ) = 0;
+        virtual Statement * mutate( SwitchStmt * switchStmt ) = 0;
+        virtual Statement * mutate( CaseStmt * caseStmt ) = 0;
+        virtual Statement * mutate( BranchStmt * branchStmt ) = 0;
+        virtual Statement * mutate( ReturnStmt * returnStmt ) = 0;
+        virtual Statement * mutate( ThrowStmt * throwStmt ) = 0;
+        virtual Statement * mutate( TryStmt * tryStmt ) = 0;
+        virtual Statement * mutate( CatchStmt * catchStmt ) = 0;
+        virtual Statement * mutate( FinallyStmt * catchStmt ) = 0;
+        virtual Statement * mutate( WaitForStmt * waitforStmt ) = 0;
+        virtual Statement * mutate( WithStmt * withStmt ) = 0;
+        virtual NullStmt * mutate( NullStmt * nullStmt ) = 0;
+        virtual Statement * mutate( DeclStmt * declStmt ) = 0;
+        virtual Statement * mutate( ImplicitCtorDtorStmt * impCtorDtorStmt ) = 0;
 
-        virtual Expression* mutate( ApplicationExpr * applicationExpr );
-        virtual Expression* mutate( UntypedExpr * untypedExpr );
-        virtual Expression* mutate( NameExpr * nameExpr );
-        virtual Expression* mutate( AddressExpr * castExpr );
-        virtual Expression* mutate( LabelAddressExpr * labAddressExpr );
-        virtual Expression* mutate( CastExpr * castExpr );
-        virtual Expression* mutate( VirtualCastExpr * castExpr );
-        virtual Expression* mutate( UntypedMemberExpr * memberExpr );
-        virtual Expression* mutate( MemberExpr * memberExpr );
-        virtual Expression* mutate( VariableExpr * variableExpr );
-        virtual Expression* mutate( ConstantExpr * constantExpr );
-        virtual Expression* mutate( SizeofExpr * sizeofExpr );
-        virtual Expression* mutate( AlignofExpr * alignofExpr );
-        virtual Expression* mutate( UntypedOffsetofExpr * offsetofExpr );
-        virtual Expression* mutate( OffsetofExpr * offsetofExpr );
-        virtual Expression* mutate( OffsetPackExpr * offsetPackExpr );
-        virtual Expression* mutate( AttrExpr * attrExpr );
-        virtual Expression* mutate( LogicalExpr * logicalExpr );
-        virtual Expression* mutate( ConditionalExpr * conditionalExpr );
-        virtual Expression* mutate( CommaExpr * commaExpr );
-        virtual Expression* mutate( TypeExpr * typeExpr );
-        virtual Expression* mutate( AsmExpr * asmExpr );
-        virtual Expression* mutate( ImplicitCopyCtorExpr * impCpCtorExpr );
-        virtual Expression* mutate( ConstructorExpr * ctorExpr );
-        virtual Expression* mutate( CompoundLiteralExpr * compLitExpr );
-        virtual Expression* mutate( RangeExpr * rangeExpr );
-        virtual Expression* mutate( UntypedTupleExpr * tupleExpr );
-        virtual Expression* mutate( TupleExpr * tupleExpr );
-        virtual Expression* mutate( TupleIndexExpr * tupleExpr );
-        virtual Expression* mutate( TupleAssignExpr * assignExpr );
-        virtual Expression* mutate( StmtExpr  * stmtExpr );
-        virtual Expression* mutate( UniqueExpr  * uniqueExpr );
-        virtual Expression* mutate( UntypedInitExpr  * initExpr );
-        virtual Expression* mutate( InitExpr  * initExpr );
+        virtual Expression * mutate( ApplicationExpr * applicationExpr ) = 0;
+        virtual Expression * mutate( UntypedExpr * untypedExpr ) = 0;
+        virtual Expression * mutate( NameExpr * nameExpr ) = 0;
+        virtual Expression * mutate( AddressExpr * addrExpr ) = 0;
+        virtual Expression * mutate( LabelAddressExpr * labAddressExpr ) = 0;
+        virtual Expression * mutate( CastExpr * castExpr ) = 0;
+        virtual Expression * mutate( KeywordCastExpr * castExpr ) = 0;
+        virtual Expression * mutate( VirtualCastExpr * castExpr ) = 0;
+        virtual Expression * mutate( UntypedMemberExpr * memberExpr ) = 0;
+        virtual Expression * mutate( MemberExpr * memberExpr ) = 0;
+        virtual Expression * mutate( VariableExpr * variableExpr ) = 0;
+        virtual Expression * mutate( ConstantExpr * constantExpr ) = 0;
+        virtual Expression * mutate( SizeofExpr * sizeofExpr ) = 0;
+        virtual Expression * mutate( AlignofExpr * alignofExpr ) = 0;
+        virtual Expression * mutate( UntypedOffsetofExpr * offsetofExpr ) = 0;
+        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;
+        virtual Expression * mutate( CommaExpr * commaExpr ) = 0;
+        virtual Expression * mutate( TypeExpr * typeExpr ) = 0;
+        virtual Expression * mutate( AsmExpr * asmExpr ) = 0;
+        virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) = 0;
+        virtual Expression * mutate( ConstructorExpr * ctorExpr ) = 0;
+        virtual Expression * mutate( CompoundLiteralExpr * compLitExpr ) = 0;
+        virtual Expression * mutate( RangeExpr * rangeExpr ) = 0;
+        virtual Expression * mutate( UntypedTupleExpr * tupleExpr ) = 0;
+        virtual Expression * mutate( TupleExpr * tupleExpr ) = 0;
+        virtual Expression * mutate( TupleIndexExpr * tupleExpr ) = 0;
+        virtual Expression * mutate( TupleAssignExpr * assignExpr ) = 0;
+        virtual Expression * mutate( StmtExpr  * stmtExpr ) = 0;
+        virtual Expression * mutate( UniqueExpr  * uniqueExpr ) = 0;
+        virtual Expression * mutate( UntypedInitExpr  * initExpr ) = 0;
+        virtual Expression * mutate( InitExpr  * initExpr ) = 0;
+        virtual Expression * mutate( DeletedExpr * delExpr ) = 0;
+        virtual Expression * mutate( DefaultArgExpr * argExpr ) = 0;
+        virtual Expression * mutate( GenericExpr * genExpr ) = 0;
 
-        virtual Type * mutate( VoidType * basicType );
-        virtual Type * mutate( BasicType * basicType );
-        virtual Type * mutate( PointerType * pointerType );
-        virtual Type * mutate( ArrayType * arrayType );
-        virtual Type * mutate( ReferenceType * refType );
-        virtual Type * mutate( FunctionType * functionType );
-        virtual Type * mutate( StructInstType * aggregateUseType );
-        virtual Type * mutate( UnionInstType * aggregateUseType );
-        virtual Type * mutate( EnumInstType * aggregateUseType );
-        virtual Type * mutate( TraitInstType * aggregateUseType );
-        virtual Type * mutate( TypeInstType * aggregateUseType );
-        virtual Type * mutate( TupleType * tupleType );
-        virtual Type * mutate( TypeofType * typeofType );
-        virtual Type * mutate( AttrType * attrType );
-        virtual Type * mutate( VarArgsType * varArgsType );
-        virtual Type * mutate( ZeroType * zeroType );
-        virtual Type * mutate( OneType * oneType );
+        virtual Type * mutate( VoidType * basicType ) = 0;
+        virtual Type * mutate( BasicType * basicType ) = 0;
+        virtual Type * mutate( PointerType * pointerType ) = 0;
+        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;
+        virtual Type * mutate( UnionInstType * aggregateUseType ) = 0;
+        virtual Type * mutate( EnumInstType * aggregateUseType ) = 0;
+        virtual Type * mutate( TraitInstType * aggregateUseType ) = 0;
+        virtual Type * mutate( TypeInstType * aggregateUseType ) = 0;
+        virtual Type * mutate( TupleType * tupleType ) = 0;
+        virtual Type * mutate( TypeofType * typeofType ) = 0;
+        virtual Type * mutate( AttrType * attrType ) = 0;
+        virtual Type * mutate( VarArgsType * varArgsType ) = 0;
+        virtual Type * mutate( ZeroType * zeroType ) = 0;
+        virtual Type * mutate( OneType * oneType ) = 0;
+        virtual Type * mutate( GlobalScopeType * globalType ) = 0;
 
-        virtual Designation * mutate( Designation * designation );
-        virtual Initializer * mutate( SingleInit * singleInit );
-        virtual Initializer * mutate( ListInit * listInit );
-        virtual Initializer * mutate( ConstructorInit * ctorInit );
+        virtual Designation * mutate( Designation * designation ) = 0 ;
+        virtual Initializer * mutate( SingleInit * singleInit ) = 0 ;
+        virtual Initializer * mutate( ListInit * listInit ) = 0 ;
+        virtual Initializer * mutate( ConstructorInit * ctorInit ) = 0 ;
 
-        virtual Subrange * mutate( Subrange * subrange );
+        virtual Subrange * mutate( Subrange * subrange ) = 0;
 
-        virtual Constant * mutate( Constant * constant );
+        virtual Constant * mutate( Constant * constant ) = 0;
 
-        virtual Attribute * mutate( Attribute * attribute );
+        virtual Attribute * mutate( Attribute * attribute ) = 0;
 
-        virtual TypeSubstitution * mutate( TypeSubstitution * sub );
-
-  private:
-        virtual Declaration * handleAggregateDecl(AggregateDecl * aggregateDecl );
-        virtual Declaration * handleNamedTypeDecl(NamedTypeDecl * typeDecl );
-        virtual Type * handleReferenceToType(ReferenceToType * aggregateUseType );
+        virtual TypeSubstitution * mutate( TypeSubstitution * sub ) = 0;
 };
 
@@ -140 +143 @@
 template< typename Container, typename MutatorType >
 inline void mutateAll( Container &container, MutatorType &mutator ) {
-        SemanticError errors;
+        SemanticErrorException errors;
         for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
                 try {
@@ -148 +151 @@
                                 assert( *i );
                         } // if
-                } catch( SemanticError &e ) {
-                        e.set_location( (*i)->location );
+                } catch( SemanticErrorException &e ) {
                         errors.append( e );
                 } // try

src/SynTree/ReferenceToType.cc

@@ -14 +14 @@
 //
 
-#include <cassert>           // for assert
-#include <list>              // for list, _List_const_iterator, list<>::cons...
-#include <ostream>           // for operator<<, basic_ostream, ostream, endl
-#include <string>            // for string, operator<<, char_traits, operator==
-
-#include "Common/utility.h"  // for printAll, cloneAll, deleteAll
-#include "Declaration.h"     // for StructDecl, UnionDecl, EnumDecl, Declara...
-#include "Expression.h"      // for Expression
-#include "Type.h"            // for TypeInstType, StructInstType, UnionInstType
+#include <cassert>            // for assert
+#include <list>               // for list, _List_const_iterator, list<>::cons...
+#include <ostream>            // for operator<<, basic_ostream, ostream, endl
+#include <string>             // for string, operator<<, char_traits, operator==
+
+#include "Common/utility.h"   // for printAll, cloneAll, deleteAll
+#include "Declaration.h"      // for StructDecl, UnionDecl, EnumDecl, Declara...
+#include "Expression.h"       // for Expression
+#include "Type.h"             // for TypeInstType, StructInstType, UnionInstType
+#include "TypeSubstitution.h" // for TypeSubstitution
 
 class Attribute;
@@ -49 +50 @@
 
 namespace {
-        void doLookup( const std::list< Declaration* > &members, const std::string &name, std::list< Declaration* > &foundDecls ) {
-                for ( std::list< Declaration* >::const_iterator i = members.begin(); i != members.end(); ++i ) {
-                        if ( (*i)->get_name() == name ) {
-                                foundDecls.push_back( *i );
+        void doLookup( const std::list< Declaration * > & members, const std::string & name, std::list< Declaration* > & foundDecls ) {
+                for ( Declaration * decl : members ) {
+                        if ( decl->name == name ) {
+                                foundDecls.push_back( decl );
                         } // if
                 } // for
@@ -59 +60 @@
 
 StructInstType::StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes ) :
-                Parent( tq, baseStruct->get_name(), attributes ), baseStruct( baseStruct ) {}
+                Parent( tq, baseStruct->name, attributes ), baseStruct( baseStruct ) {}
 
 std::string StructInstType::typeString() const { return "struct"; }
+
+const std::list<TypeDecl*>* StructInstType::get_baseParameters() const {
+        if ( ! baseStruct ) return nullptr;
+        return &baseStruct->get_parameters();
+}
 
 std::list<TypeDecl*>* StructInstType::get_baseParameters() {
@@ -70 +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 {
+        return TypeSubstitution( get_baseParameters()->begin(), get_baseParameters()->end(), parameters.begin() );
+}
 
 void StructInstType::lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const {
         assert( baseStruct );
-        doLookup( baseStruct->get_members(), name, foundDecls );
+        doLookup( baseStruct->members, name, foundDecls );
 }
 
@@ -93 +103 @@
 
 UnionInstType::UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes ) :
-                Parent( tq, baseUnion->get_name(), attributes ), baseUnion( baseUnion ) {}
+                Parent( tq, baseUnion->name, attributes ), baseUnion( baseUnion ) {}
 
 std::string UnionInstType::typeString() const { return "union"; }
@@ -102 +112 @@
 }
 
+const std::list< TypeDecl * > * UnionInstType::get_baseParameters() const {
+        if ( ! baseUnion ) return nullptr;
+        return &baseUnion->get_parameters();
+}
+
 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 {
+        return TypeSubstitution( get_baseParameters()->begin(), get_baseParameters()->end(), parameters.begin() );
+}
 
 void UnionInstType::lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const {
         assert( baseUnion );
-        doLookup( baseUnion->get_members(), name, foundDecls );
+        doLookup( baseUnion->members, name, foundDecls );
 }
 
@@ -133 +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;

src/SynTree/ReferenceType.cc

@@ -16 +16 @@
 #include "Type.h"
 #include "Expression.h"
+#include "TypeSubstitution.h"
 #include "Common/utility.h"
 
@@ -35 +36 @@
 }
 
+TypeSubstitution ReferenceType::genericSubstitution() const { return base->genericSubstitution(); }
+
 void ReferenceType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );

src/SynTree/Statement.cc

@@ -34 +34 @@
 Statement::Statement( const std::list<Label> & labels ) : labels( labels ) {}
 
-void Statement::print( std::ostream & os, Indenter ) const {
+void Statement::print( std::ostream & os, Indenter indent ) const {
         if ( ! labels.empty() ) {
-                os << "Labels: {";
+                os << indent << "... Labels: {";
                 for ( const Label & l : labels ) {
                         os << l << ",";
@@ -94 +94 @@
 
 
+DirectiveStmt::DirectiveStmt( const std::string & directive ) : Statement(), directive( directive ) {}
+
+void DirectiveStmt::print( std::ostream &os, Indenter ) const {
+        os << "GCC Directive:" << directive << endl;
+}
+
+
 const char *BranchStmt::brType[] = { "Goto", "Break", "Continue" };
 
-BranchStmt::BranchStmt( Label target, Type type ) throw ( SemanticError ) :
+BranchStmt::BranchStmt( Label target, Type type ) throw ( SemanticErrorException ) :
         Statement(), originalTarget( target ), target( target ), computedTarget( nullptr ), type( type ) {
         //actually this is a syntactic error signaled by the parser
         if ( type == BranchStmt::Goto && target.empty() ) {
-                throw SemanticError("goto without target");
-        }
-}
-
-BranchStmt::BranchStmt( Expression *computedTarget, Type type ) throw ( SemanticError ) :
+                SemanticError( target.get_statement()->location, "goto without target");
+        }
+}
+
+BranchStmt::BranchStmt( Expression *computedTarget, Type type ) throw ( SemanticErrorException ) :
         Statement(), computedTarget( computedTarget ), type( type ) {
         if ( type != BranchStmt::Goto || computedTarget == nullptr ) {
-                throw SemanticError("Computed target not valid in branch statement");
+                SemanticError( computedTarget->location, "Computed target not valid in branch statement");
         }
 }
@@ -201 +208 @@
 }
 
-CaseStmt::CaseStmt( Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
+CaseStmt::CaseStmt( Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticErrorException ) :
         Statement(), condition( condition ), stmts( statements ), _isDefault( deflt ) {
-        if ( isDefault() && condition != 0 ) throw SemanticError("default case with condition: ", condition);
+        if ( isDefault() && condition != 0 ) SemanticError( condition, "default case with condition: " );
 }
 
@@ -223 +230 @@
 
 void CaseStmt::print( std::ostream &os, Indenter indent ) const {
-        if ( isDefault() ) os << "Default ";
+        if ( isDefault() ) os << indent << "Default ";
         else {
-                os << "Case ";
+                os << indent << "Case ";
                 condition->print( os, indent );
         } // if
@@ -231 +238 @@
 
         for ( Statement * stmt : stmts ) {
+                os << indent+1;
                 stmt->print( os, indent+1 );
         }
 }
 
-WhileStmt::WhileStmt( Expression *condition, Statement *body, bool isDoWhile ):
-        Statement(), condition( condition), body( body), isDoWhile( isDoWhile) {
+WhileStmt::WhileStmt( Expression *condition, Statement *body, std::list< Statement * > & initialization, bool isDoWhile ):
+        Statement(), condition( condition), body( body), initialization( initialization ), isDoWhile( isDoWhile) {
 }
 
@@ -452 +460 @@
 void WaitForStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Waitfor Statement" << endl;
-        os << indent << "... with block:" << endl << indent+1;
-        // block->print( os, indent + 4 );
+        indent += 1;
+        for( auto & clause : clauses ) {
+                os << indent << "target function :";
+                if(clause.target.function) { clause.target.function->print(os, indent + 1); }
+                os << endl << indent << "with arguments :" << endl;
+                for( auto & thing : clause.target.arguments) {
+                        if(thing) { thing->print(os, indent + 1); }
+                }
+                os << indent << " with statment :" << endl;
+                if(clause.statement) { clause.statement->print(os, indent + 1); }
+
+                os << indent << " with condition :" << endl;
+                if(clause.condition) { clause.condition->print(os, indent + 1); }
+        }
+
+        os << indent << " timeout of :" << endl;
+        if(timeout.time) { timeout.time->print(os, indent + 1); }
+
+        os << indent << " with statment :" << endl;
+        if(timeout.statement) { timeout.statement->print(os, indent + 1); }
+
+        os << indent << " with condition :" << endl;
+        if(timeout.condition) { timeout.condition->print(os, indent + 1); }
+
+
+        os << indent << " else :" << endl;
+        if(orelse.statement) { orelse.statement->print(os, indent + 1); }
+
+        os << indent << " with condition :" << endl;
+        if(orelse.condition) { orelse.condition->print(os, indent + 1); }
 }
 
@@ -468 +504 @@
 void WithStmt::print( std::ostream & os, Indenter indent ) const {
         os << "With statement" << endl;
+        os << indent << "... with expressions: " << endl;
+        printAll( exprs, os, indent+1 );
         os << indent << "... with statement:" << endl << indent+1;
         stmt->print( os, indent+1 );
@@ -476 +514 @@
 }
 
-void NullStmt::print( std::ostream &os, Indenter ) const {
+void NullStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Null Statement" << endl;
+        Statement::print( os, indent );
 }
 

src/SynTree/Statement.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Sep  3 20:46:46 2017
-// Update Count     : 77
+// Last Modified On : Thu Mar  8 14:53:02 2018
+// Update Count     : 78
 //
 
@@ -126 +126 @@
 };
 
+class DirectiveStmt : public Statement {
+        public:
+        std::string directive;
+
+        DirectiveStmt( const std::string & );
+        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;
+};
+
 class IfStmt : public Statement {
   public:
@@ -179 +192 @@
         std::list<Statement *> stmts;
 
-        CaseStmt( Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
+        CaseStmt( Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw (SemanticErrorException);
         CaseStmt( const CaseStmt &other );
         virtual ~CaseStmt();
@@ -207 +220 @@
         Expression *condition;
         Statement *body;
+        std::list<Statement *> initialization;
         bool isDoWhile;
 
         WhileStmt( Expression *condition,
-               Statement *body, bool isDoWhile = false );
+               Statement *body, std::list<Statement *> & initialization, bool isDoWhile = false );
         WhileStmt( const WhileStmt &other );
         virtual ~WhileStmt();
@@ -255 +269 @@
 class BranchStmt : public Statement {
   public:
-        enum Type { Goto = 0, Break, Continue };
+        enum Type { Goto = 0, Break, Continue, FallThrough, FallThroughDefault };
 
         // originalTarget kept for error messages.
@@ -263 +277 @@
         Type type;
 
-        BranchStmt( Label target, Type ) throw (SemanticError);
-        BranchStmt( Expression *computedTarget, Type ) throw (SemanticError);
+        BranchStmt( Label target, Type ) throw (SemanticErrorException);
+        BranchStmt( Expression *computedTarget, Type ) throw (SemanticErrorException);
 
         Label get_originalTarget() { return originalTarget; }

src/SynTree/SynTree.h

@@ -38 +38 @@
 class TypedefDecl;
 class AsmDecl;
+class StaticAssertDecl;
 
 class Statement;
@@ -43 +44 @@
 class ExprStmt;
 class AsmStmt;
+class DirectiveStmt;
 class IfStmt;
 class WhileStmt;
@@ -68 +70 @@
 class LabelAddressExpr;
 class CastExpr;
+class KeywordCastExpr;
 class VirtualCastExpr;
 class MemberExpr;
@@ -97 +100 @@
 class UntypedInitExpr;
 class InitExpr;
+class DeletedExpr;
+class DefaultArgExpr;
+class GenericExpr;
 
 class Type;
@@ -104 +110 @@
 class ArrayType;
 class ReferenceType;
+class QualifiedType;
 class FunctionType;
 class ReferenceToType;
@@ -117 +124 @@
 class ZeroType;
 class OneType;
+class GlobalScopeType;
 
 class Designation;

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 : Fri Jun 22 10:17:19 2018
+// Update Count     : 39
 //
 #include "Type.h"
 
-#include "Attribute.h"               // for Attribute
-#include "Common/utility.h"          // for cloneAll, deleteAll, printAll
-#include "InitTweak/InitTweak.h"     // for getPointerBase
-#include "SynTree/BaseSyntaxNode.h"  // for BaseSyntaxNode
-#include "SynTree/Declaration.h"     // for TypeDecl
+#include "Attribute.h"                // for Attribute
+#include "Common/utility.h"           // for cloneAll, deleteAll, printAll
+#include "InitTweak/InitTweak.h"      // for getPointerBase
+#include "SynTree/BaseSyntaxNode.h"   // for BaseSyntaxNode
+#include "SynTree/Declaration.h"      // for TypeDecl
+#include "SynTree/TypeSubstitution.h" // for TypeSubstitution
 
 using namespace std;
 
-const char *BasicType::typeNames[BasicType::NUMBER_OF_BASIC_TYPES] = {
+const char *BasicType::typeNames[] = {
         "_Bool",
         "char",
@@ -47 +48 @@
         "__int128",
         "unsigned __int128",
+        "__float80",
+        "__float128"
 };
+static_assert(
+        sizeof(BasicType::typeNames)/sizeof(BasicType::typeNames[0]) == BasicType::NUMBER_OF_BASIC_TYPES,
+        "Each basic type name should have a corresponding kind enum value"
+);
 
 Type::Type( const Qualifiers &tq, const std::list< Attribute * > & attributes ) : tq( tq ), attributes( attributes ) {}
@@ -62 +69 @@
 
 // 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" };
@@ -81 +88 @@
 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 {
         if ( ! forall.empty() ) {
@@ -96 +105 @@
 }
 
+
+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

@@ -178 +178 @@
         virtual bool isComplete() const { return true; }
 
-        virtual AggregateDecl * getAggr() {     assertf( false, "Non-aggregate type: %s", toString( this ).c_str() ); }
+        virtual AggregateDecl * getAggr() const { assertf( false, "Non-aggregate type: %s", toCString( this ) ); }
+
+        virtual TypeSubstitution genericSubstitution() const;
 
         virtual Type *clone() const = 0;
@@ -229 +231 @@
                 SignedInt128,
                 UnsignedInt128,
+                Float80,
+                Float128,
                 NUMBER_OF_BASIC_TYPES
         } kind;
@@ -311 +315 @@
 };
 
+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 Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
+
 class ReferenceType : public Type {
 public:
@@ -328 +347 @@
         // the number of values are disallowed.
         virtual unsigned size() const override { return base->size(); }
+
+        virtual TypeSubstitution genericSubstitution() const override;
 
         virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
@@ -356 +377 @@
         bool isTtype() const;
 
+        bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
+
         virtual FunctionType *clone() const override { return new FunctionType( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
@@ -404 +427 @@
         /// Accesses generic parameters of base struct (NULL if none such)
         std::list<TypeDecl*> * get_baseParameters();
+        const std::list<TypeDecl*> * get_baseParameters() const;
 
         virtual bool isComplete() const override;
 
-        virtual AggregateDecl * getAggr() override;
+        virtual AggregateDecl * getAggr() const override;
+
+        virtual TypeSubstitution genericSubstitution() const override;
 
         /// Looks up the members of this struct named "name" and places them into "foundDecls".
@@ -437 +463 @@
 
         /// Accesses generic parameters of base union (NULL if none such)
-        std::list< TypeDecl * > * get_baseParameters();
+        std::list<TypeDecl*> * get_baseParameters();
+        const std::list<TypeDecl*> * get_baseParameters() const;
 
         virtual bool isComplete() const override;
 
-        virtual AggregateDecl * getAggr() override;
+        virtual AggregateDecl * getAggr() const override;
+
+        virtual TypeSubstitution genericSubstitution() const override;
 
         /// looks up the members of this union named "name" and places them into "foundDecls"
@@ -471 +500 @@
 
         virtual bool isComplete() const override;
+
+        virtual AggregateDecl * getAggr() const override;
 
         virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
@@ -651 +682 @@
 };
 
+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 Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
+
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/TypeSubstitution.cc

@@ -106 +106 @@
 }
 
+namespace {
+        struct EnvTrimmer {
+                TypeSubstitution * env, * newEnv;
+                EnvTrimmer( TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
+                void previsit( TypeDecl * tyDecl ) {
+                        // transfer known bindings for seen type variables
+                        if ( Type * t = env->lookup( tyDecl->name ) ) {
+                                newEnv->add( tyDecl->name, t );
+                        }
+                }
+        };
+} // namespace
+
+/// reduce environment to just the parts that are referenced in a given expression
+TypeSubstitution * TypeSubstitution::newFromExpr( Expression * expr, TypeSubstitution * env ) {
+        if ( env ) {
+                TypeSubstitution * newEnv = new TypeSubstitution();
+                PassVisitor<EnvTrimmer> trimmer( env, newEnv );
+                expr->accept( trimmer );
+                return newEnv;
+        }
+        return nullptr;
+}
+
 void TypeSubstitution::normalize() {
+        PassVisitor<Substituter> sub( *this, true );
         do {
-                subCount = 0;
-                freeOnly = true;
+                sub.pass.subCount = 0;
+                sub.pass.freeOnly = true;
                 for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
-                        i->second = i->second->acceptMutator( *this );
+                        i->second = i->second->acceptMutator( sub );
                 }
-        } while ( subCount );
-}
-
-Type * TypeSubstitution::mutate( TypeInstType *inst ) {
-        BoundVarsType::const_iterator bound = boundVars.find( inst->get_name() );
+        } while ( sub.pass.subCount );
+}
+
+Type * TypeSubstitution::Substituter::postmutate( TypeInstType *inst ) {
+        BoundVarsType::const_iterator bound = boundVars.find( inst->name );
         if ( bound != boundVars.end() ) return inst;
 
-        TypeEnvType::const_iterator i = typeEnv.find( inst->get_name() );
-        if ( i == typeEnv.end() ) {
+        TypeEnvType::const_iterator i = sub.typeEnv.find( inst->get_name() );
+        if ( i == sub.typeEnv.end() ) {
                 return inst;
         } else {
-///         std::cout << "found " << inst->get_name() << ", replacing with ";
-///         i->second->print( std::cout );
-///         std::cout << std::endl;
+                // cut off infinite loop for the case where a type is bound to itself.
+                // Note: this does not prevent cycles in the general case, so it may be necessary to do something more sophisticated here.
+                // TODO: investigate preventing type variables from being bound to themselves in the first place.
+                if ( TypeInstType * replacement = dynamic_cast< TypeInstType * >( i->second ) ) {
+                        if ( inst->name == replacement->name ) {
+                                return inst;
+                        }
+                }
+                // std::cerr << "found " << inst->name << ", replacing with " << i->second << std::endl;
                 subCount++;
-                Type *newtype = i->second->clone();
+                Type * newtype = i->second->clone();
                 newtype->get_qualifiers() |= inst->get_qualifiers();
                 delete inst;
-                return newtype;
-        } // if
-}
-
-Expression * TypeSubstitution::mutate( NameExpr *nameExpr ) {
-        VarEnvType::const_iterator i = varEnv.find( nameExpr->get_name() );
-        if ( i == varEnv.end() ) {
+                // Note: need to recursively apply substitution to the new type because normalize does not substitute bound vars, but bound vars must be substituted when not in freeOnly mode.
+                return newtype->acceptMutator( *visitor );
+        } // if
+}
+
+Expression * TypeSubstitution::Substituter::postmutate( NameExpr * nameExpr ) {
+        VarEnvType::const_iterator i = sub.varEnv.find( nameExpr->name );
+        if ( i == sub.varEnv.end() ) {
                 return nameExpr;
         } else {
@@ -146 +178 @@
 }
 
-template< typename TypeClass >
-Type *TypeSubstitution::handleType( TypeClass *type ) {
-        ValueGuard<BoundVarsType> oldBoundVars( boundVars );
+void TypeSubstitution::Substituter::premutate( Type * type ) {
+        GuardValue( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
-                for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
-                        boundVars.insert( (*tyvar )->get_name() );
+                for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) {
+                        boundVars.insert( (*tyvar)->name );
                 } // for
         } // if
-        Type *ret = Mutator::mutate( type );
-        return ret;
 }
 
 template< typename TypeClass >
-Type *TypeSubstitution::handleAggregateType( TypeClass *type ) {
-        ValueGuard<BoundVarsType> oldBoundVars( boundVars );
+void TypeSubstitution::Substituter::handleAggregateType( TypeClass * type ) {
+        GuardValue( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
-                for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
-                        boundVars.insert( (*tyvar )->get_name() );
+                for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) {
+                        boundVars.insert( (*tyvar)->name );
                 } // for
                 // bind type variables from generic type instantiations
                 std::list< TypeDecl* > *baseParameters = type->get_baseParameters();
-                if ( baseParameters && ! type->get_parameters().empty() ) {
+                if ( baseParameters && ! type->parameters.empty() ) {
                         for ( std::list< TypeDecl* >::const_iterator tyvar = baseParameters->begin(); tyvar != baseParameters->end(); ++tyvar ) {
-                                boundVars.insert( (*tyvar)->get_name() );
+                                boundVars.insert( (*tyvar)->name );
                         } // for
                 } // if
         } // if
-        Type *ret = Mutator::mutate( type );
-        return ret;
-}
-
-Type * TypeSubstitution::mutate( VoidType *voidType ) {
-        return handleType( voidType );
-}
-
-Type * TypeSubstitution::mutate( BasicType *basicType ) {
-        return handleType( basicType );
-}
-
-Type * TypeSubstitution::mutate( PointerType *pointerType ) {
-        return handleType( pointerType );
-}
-
-Type * TypeSubstitution::mutate( ArrayType *arrayType ) {
-        return handleType( arrayType );
-}
-
-Type * TypeSubstitution::mutate( FunctionType *functionType ) {
-        return handleType( functionType );
-}
-
-Type * TypeSubstitution::mutate( StructInstType *aggregateUseType ) {
-        return handleAggregateType( aggregateUseType );
-}
-
-Type * TypeSubstitution::mutate( UnionInstType *aggregateUseType ) {
-        return handleAggregateType( aggregateUseType );
-}
-
-Type * TypeSubstitution::mutate( EnumInstType *aggregateUseType ) {
-        return handleType( aggregateUseType );
-}
-
-Type * TypeSubstitution::mutate( TraitInstType *aggregateUseType ) {
-        return handleType( aggregateUseType );
-}
-
-Type * TypeSubstitution::mutate( TupleType *tupleType ) {
-        return handleType( tupleType );
-}
-
-Type * TypeSubstitution::mutate( VarArgsType *varArgsType ) {
-        return handleType( varArgsType );
-}
-
-Type * TypeSubstitution::mutate( ZeroType *zeroType ) {
-        return handleType( zeroType );
-}
-
-Type * TypeSubstitution::mutate( OneType *oneType ) {
-        return handleType( oneType );
+}
+
+void TypeSubstitution::Substituter::premutate( StructInstType * aggregateUseType ) {
+        handleAggregateType( aggregateUseType );
+}
+
+void TypeSubstitution::Substituter::premutate( UnionInstType *aggregateUseType ) {
+        handleAggregateType( aggregateUseType );
 }
 

src/SynTree/TypeSubstitution.h

@@ -27 +27 @@
 #include "SynTree/Declaration.h"   // for TypeDecl, Declaration (ptr only)
 #include "SynTree/Expression.h"    // for Expression (ptr only), NameExpr (p...
-#include "SynTree/Mutator.h"       // for Mutator
 #include "SynTree/Type.h"          // for Type, ArrayType (ptr only), BasicT...
 
-class TypeSubstitution : public Mutator {
-        typedef Mutator Parent;
+class TypeSubstitution {
   public:
         TypeSubstitution();
@@ -57 +55 @@
         void extract( TypeInstListIterator begin, TypeInstListIterator end, TypeSubstitution &result );
 
+        /// create a new TypeSubstitution using bindings from env containing all of the type variables in expr
+        static TypeSubstitution * newFromExpr( Expression * expr, TypeSubstitution * env );
+
         void normalize();
 
@@ -64 +65 @@
         TypeSubstitution *clone() const { return new TypeSubstitution( *this ); }
   private:
-        virtual Type* mutate(TypeInstType *aggregateUseType);
-        virtual Expression* mutate(NameExpr *nameExpr);
-
-        /// Records type variable bindings from forall-statements
-        template< typename TypeClass > Type *handleType( TypeClass *type );
-        /// Records type variable bindings from forall-statements and instantiations of generic types
-        template< typename TypeClass > Type *handleAggregateType( TypeClass *type );
-
-        virtual Type* mutate(VoidType *basicType);
-        virtual Type* mutate(BasicType *basicType);
-        virtual Type* mutate(PointerType *pointerType);
-        virtual Type* mutate(ArrayType *arrayType);
-        virtual Type* mutate(FunctionType *functionType);
-        virtual Type* mutate(StructInstType *aggregateUseType);
-        virtual Type* mutate(UnionInstType *aggregateUseType);
-        virtual Type* mutate(EnumInstType *aggregateUseType);
-        virtual Type* mutate(TraitInstType *aggregateUseType);
-        virtual Type* mutate(TupleType *tupleType);
-        virtual Type* mutate(VarArgsType *varArgsType);
-        virtual Type* mutate(ZeroType *zeroType);
-        virtual Type* mutate(OneType *oneType);
+
+        // Mutator that performs the substitution
+        struct Substituter;
 
         // TODO: worry about traversing into a forall-qualified function type or type decl with assertions
@@ -97 +80 @@
         typedef std::map< std::string, Type* > TypeEnvType;
         typedef std::map< std::string, Expression* > VarEnvType;
-        typedef std::set< std::string > BoundVarsType;
         TypeEnvType typeEnv;
         VarEnvType varEnv;
-        BoundVarsType boundVars;
-        int subCount;
-        bool freeOnly;
+
+  public:
+        // has to come after declaration of typeEnv
+        auto begin()       -> decltype( typeEnv.begin() ) { return typeEnv.begin(); }
+        auto   end()       -> decltype( typeEnv.  end() ) { return typeEnv.  end(); }
+        auto begin() const -> decltype( typeEnv.begin() ) { return typeEnv.begin(); }
+        auto   end() const -> decltype( typeEnv.  end() ) { return typeEnv.  end(); }
 };
 
@@ -122 +108 @@
                                 } // if
                         } else {
-                                throw SemanticError( toString( "Attempt to provide non-type parameter: ", toString( *actualIt ).c_str(), " for type parameter " ), formal );
+                                SemanticError( formal, toString( "Attempt to provide non-type parameter: ", toString( *actualIt ).c_str(), " for type parameter " ) );
                         } // if
                 } else {
@@ -134 +120 @@
 
 template< typename FormalIterator, typename ActualIterator >
-TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin )
-{
+TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) {
         add( formalBegin, formalEnd, actualBegin );
 }
+
+// include needs to happen after TypeSubstitution is defined so that both TypeSubstitution and
+// PassVisitor are defined before PassVisitor implementation accesses TypeSubstitution internals.
+#include "Common/PassVisitor.h"
+
+// 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 ) {}
+
+                Type * postmutate( TypeInstType * aggregateUseType );
+                Expression * postmutate( NameExpr * nameExpr );
+
+                /// Records type variable bindings from forall-statements
+                void premutate( Type * type );
+                /// Records type variable bindings from forall-statements and instantiations of generic types
+                template< typename TypeClass > void handleAggregateType( TypeClass * type );
+
+                void premutate( StructInstType * aggregateUseType );
+                void premutate( UnionInstType * aggregateUseType );
+
+                TypeSubstitution & sub;
+                int subCount = 0;
+                bool freeOnly;
+                typedef std::set< std::string > BoundVarsType;
+                BoundVarsType boundVars;
+};
 
 template< typename SynTreeClass >
 int TypeSubstitution::apply( SynTreeClass *&input ) {
         assert( input );
-        subCount = 0;
-        freeOnly = false;
-        input = dynamic_cast< SynTreeClass *>( input->acceptMutator( *this ) );
-        assert( input );
-///     std::cout << "substitution result is: ";
-///     newType->print( std::cout );
-///     std::cout << std::endl;
-        return subCount;
+        PassVisitor<Substituter> sub( *this, false );
+        input = dynamic_cast< SynTreeClass * >( input->acceptMutator( sub ) );
+        assert( input );
+///     std::cerr << "substitution result is: ";
+///     newType->print( std::cerr );
+///     std::cerr << std::endl;
+        return sub.pass.subCount;
 }
 
@@ -155 +165 @@
 int TypeSubstitution::applyFree( SynTreeClass *&input ) {
         assert( input );
-        subCount = 0;
-        freeOnly = true;
-        input = dynamic_cast< SynTreeClass *>( input->acceptMutator( *this ) );
-        assert( input );
-///     std::cout << "substitution result is: ";
-///     newType->print( std::cout );
-///     std::cout << std::endl;
-        return subCount;
+        PassVisitor<Substituter> sub( *this, true );
+        input = dynamic_cast< SynTreeClass * >( input->acceptMutator( sub ) );
+        assert( input );
+///     std::cerr << "substitution result is: ";
+///     newType->print( std::cerr );
+///     std::cerr << std::endl;
+        return sub.pass.subCount;
 }
 

src/SynTree/Visitor.h

@@ -21 +21 @@
 class Visitor {
   protected:
-        Visitor();
-        virtual ~Visitor();
+        Visitor() = default;
+        virtual ~Visitor() = default;
   public:
         // visit: Default implementation of all functions visits the children
         // of the given syntax node, but performs no other action.
 
-        virtual void visit( ObjectDecl * objectDecl );
-        virtual void visit( FunctionDecl * functionDecl );
-        virtual void visit( StructDecl * aggregateDecl );
-        virtual void visit( UnionDecl * aggregateDecl );
-        virtual void visit( EnumDecl * aggregateDecl );
-        virtual void visit( TraitDecl * aggregateDecl );
-        virtual void visit( TypeDecl * typeDecl );
-        virtual void visit( TypedefDecl * typeDecl );
-        virtual void visit( AsmDecl * asmDecl );
+        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 );
-        virtual void visit( ExprStmt * exprStmt );
-        virtual void visit( AsmStmt * asmStmt );
-        virtual void visit( IfStmt * ifStmt );
-        virtual void visit( WhileStmt * whileStmt );
-        virtual void visit( ForStmt * forStmt );
-        virtual void visit( SwitchStmt * switchStmt );
-        virtual void visit( CaseStmt * caseStmt );
-        virtual void visit( BranchStmt * branchStmt );
-        virtual void visit( ReturnStmt * returnStmt );
-        virtual void visit( ThrowStmt * throwStmt );
-        virtual void visit( TryStmt * tryStmt );
-        virtual void visit( CatchStmt * catchStmt );
-        virtual void visit( FinallyStmt * finallyStmt );
-        virtual void visit( WaitForStmt * waitforStmt );
-        virtual void visit( WithStmt * withStmt );
-        virtual void visit( NullStmt * nullStmt );
-        virtual void visit( DeclStmt * declStmt );
-        virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt );
+        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 );
-        virtual void visit( UntypedExpr * untypedExpr );
-        virtual void visit( NameExpr * nameExpr );
-        virtual void visit( CastExpr * castExpr );
-        virtual void visit( VirtualCastExpr * castExpr );
-        virtual void visit( AddressExpr * addressExpr );
-        virtual void visit( LabelAddressExpr * labAddressExpr );
-        virtual void visit( UntypedMemberExpr * memberExpr );
-        virtual void visit( MemberExpr * memberExpr );
-        virtual void visit( VariableExpr * variableExpr );
-        virtual void visit( ConstantExpr * constantExpr );
-        virtual void visit( SizeofExpr * sizeofExpr );
-        virtual void visit( AlignofExpr * alignofExpr );
-        virtual void visit( UntypedOffsetofExpr * offsetofExpr );
-        virtual void visit( OffsetofExpr * offsetofExpr );
-        virtual void visit( OffsetPackExpr * offsetPackExpr );
-        virtual void visit( AttrExpr * attrExpr );
-        virtual void visit( LogicalExpr * logicalExpr );
-        virtual void visit( ConditionalExpr * conditionalExpr );
-        virtual void visit( CommaExpr * commaExpr );
-        virtual void visit( TypeExpr * typeExpr );
-        virtual void visit( AsmExpr * asmExpr );
-        virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
-        virtual void visit( ConstructorExpr *  ctorExpr );
-        virtual void visit( CompoundLiteralExpr * compLitExpr );
-        virtual void visit( RangeExpr * rangeExpr );
-        virtual void visit( UntypedTupleExpr * tupleExpr );
-        virtual void visit( TupleExpr * tupleExpr );
-        virtual void visit( TupleIndexExpr * tupleExpr );
-        virtual void visit( TupleAssignExpr * assignExpr );
-        virtual void visit( StmtExpr *  stmtExpr );
-        virtual void visit( UniqueExpr *  uniqueExpr );
-        virtual void visit( UntypedInitExpr *  initExpr );
-        virtual void visit( InitExpr *  initExpr );
+        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( DefaultArgExpr * argExpr ) = 0;
+        virtual void visit( GenericExpr * genExpr ) = 0;
 
-        virtual void visit( VoidType * basicType );
-        virtual void visit( BasicType * basicType );
-        virtual void visit( PointerType * pointerType );
-        virtual void visit( ArrayType * arrayType );
-        virtual void visit( ReferenceType * refType );
-        virtual void visit( FunctionType * functionType );
-        virtual void visit( StructInstType * aggregateUseType );
-        virtual void visit( UnionInstType * aggregateUseType );
-        virtual void visit( EnumInstType * aggregateUseType );
-        virtual void visit( TraitInstType * aggregateUseType );
-        virtual void visit( TypeInstType * aggregateUseType );
-        virtual void visit( TupleType * tupleType );
-        virtual void visit( TypeofType * typeofType );
-        virtual void visit( AttrType * attrType );
-        virtual void visit( VarArgsType * varArgsType );
-        virtual void visit( ZeroType * zeroType );
-        virtual void visit( OneType * oneType );
+        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( QualifiedType * qualType ) = 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( GlobalScopeType * globalType ) = 0;
 
-        virtual void visit( Designation * designation );
-        virtual void visit( SingleInit * singleInit );
-        virtual void visit( ListInit * listInit );
-        virtual void visit( ConstructorInit * ctorInit );
+        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 );
+        virtual void visit( Subrange * subrange ) = 0;
 
-        virtual void visit( Constant * constant );
+        virtual void visit( Constant * constant ) = 0;
 
-        virtual void visit( Attribute * attribute );
-  private:
-        virtual void handleAggregateDecl( AggregateDecl *aggregateDecl );
-        virtual void handleNamedTypeDecl( NamedTypeDecl *typeDecl );
-        virtual void handleReferenceToType( ReferenceToType *aggregateUseType );
+        virtual void visit( Attribute * attribute ) = 0;
 };
 
@@ -135 +139 @@
 template< typename Container, typename VisitorType >
 inline void acceptAll( Container &container, VisitorType &visitor ) {
-        SemanticError errors;
+        SemanticErrorException errors;
         for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
                 try {
@@ -141 +145 @@
                                 (*i)->accept( visitor );
                         }
-                } catch( SemanticError &e ) {
-                        e.set_location( (*i)->location );
+                } catch( SemanticErrorException &e ) {
                         errors.append( e );
                 }

src/SynTree/module.mk

@@ -46 +46 @@
        SynTree/TypeDecl.cc \
        SynTree/Initializer.cc \
-       SynTree/Visitor.cc \
-       SynTree/Mutator.cc \
        SynTree/TypeSubstitution.cc \
        SynTree/Attribute.cc \
-       SynTree/VarExprReplacer.cc
+       SynTree/DeclReplacer.cc