Changeset 6840e7c for src/SynTree

Timestamp:

Oct 19, 2017, 12:01:04 PM (8 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:

837ce06

Parents:

b96ec83 (diff), a15b72c (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:

• AddressExpr.cc (modified) (4 diffs)
• AggregateDecl.cc (modified) (1 diff)
• ApplicationExpr.cc (modified) (2 diffs)
• ArrayType.cc (modified) (1 diff)
• AttrType.cc (modified) (2 diffs)
• Attribute.cc (modified) (2 diffs)
• Attribute.h (modified) (1 diff)
• BaseSyntaxNode.h (modified) (2 diffs)
• BasicType.cc (modified) (3 diffs)
• CommaExpr.cc (modified) (2 diffs)
• CompoundStmt.cc (modified) (1 diff)
• Constant.cc (modified) (1 diff)
• Constant.h (modified) (4 diffs)
• DeclStmt.cc (modified) (1 diff)
• Declaration.cc (modified) (2 diffs)
• Declaration.h (modified) (7 diffs)
• Expression.cc (modified) (30 diffs)
• Expression.h (modified) (57 diffs)
• FunctionDecl.cc (modified) (2 diffs)
• FunctionType.cc (modified) (2 diffs)
• Initializer.cc (modified) (4 diffs)
• Initializer.h (modified) (5 diffs)
• Mutator.cc (modified) (1 diff)
• Mutator.h (modified) (1 diff)
• NamedTypeDecl.cc (modified) (2 diffs)
• ObjectDecl.cc (modified) (3 diffs)
• PointerType.cc (modified) (1 diff)
• ReferenceToType.cc (modified) (10 diffs)
• ReferenceType.cc (modified) (1 diff)
• Statement.cc (modified) (18 diffs)
• Statement.h (modified) (19 diffs)
• TupleExpr.cc (modified) (5 diffs)
• TupleType.cc (modified) (1 diff)
• Type.cc (modified) (4 diffs)
• Type.h (modified) (20 diffs)
• TypeDecl.cc (modified) (1 diff)
• TypeExpr.cc (modified) (1 diff)
• TypeSubstitution.cc (modified) (5 diffs)
• TypeSubstitution.h (modified) (2 diffs)
• TypeofType.cc (modified) (2 diffs)
• VarArgsType.cc (modified) (1 diff)
• VoidType.cc (modified) (2 diffs)
• ZeroOneType.cc (modified) (2 diffs)

src/SynTree/AddressExpr.cc

@@ -33 +33 @@
         Type * addrType( Type * type ) {
                 if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( type ) ) {
-                        return new ReferenceType( refType->get_qualifiers(), addrType( refType->get_base() ) );
+                        return new ReferenceType( refType->get_qualifiers(), addrType( refType->base ) );
                 } else {
                         return new PointerType( Type::Qualifiers(), type->clone() );
@@ -40 +40 @@
 }
 
-AddressExpr::AddressExpr( Expression *arg, Expression *_aname ) : Expression( _aname ), arg( arg ) {
-        if ( arg->has_result() ) {
-                if ( arg->get_result()->get_lvalue() ) {
+AddressExpr::AddressExpr( Expression *arg ) : Expression(), arg( arg ) {
+        if ( arg->result ) {
+                if ( arg->result->get_lvalue() ) {
                         // lvalue, retains all layers of reference and gains a pointer inside the references
-                        set_result( addrType( arg->get_result() ) );
+                        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->get_result() );
-                        set_result( addrType( refType->get_base() ) );
+                        ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( arg->result );
+                        set_result( addrType( refType->base ) );
                 }
                 // result of & is never an lvalue
@@ -62 +62 @@
 }
 
-void AddressExpr::print( std::ostream &os, int indent ) const {
+void AddressExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Address of:" << std::endl;
         if ( arg ) {
-                os << std::string( indent+2, ' ' );
-                arg->print( os, indent+2 );
+                os << indent+1;
+                arg->print( os, indent+1 );
         } // if
 }
@@ -77 +77 @@
 LabelAddressExpr::~LabelAddressExpr() {}
 
-void LabelAddressExpr::print( std::ostream & os, int indent ) const {
-        os << "Address of label:" << std::endl << std::string( indent+2, ' ' ) << arg;
+void LabelAddressExpr::print( std::ostream & os, Indenter ) const {
+        os << "Address of label:" << arg;
 }
 

src/SynTree/AggregateDecl.cc

@@ -41 +41 @@
 }
 
-void AggregateDecl::print( std::ostream &os, int indent ) const {
+void AggregateDecl::print( std::ostream &os, Indenter indent ) const {
         using std::string;
         using std::endl;
 
-        os << typeString() << " " << get_name() << ":";
+        os << typeString() << " " << name << ":";
         if ( get_linkage() != LinkageSpec::Cforall ) {
-                os << " " << LinkageSpec::linkageName( get_linkage() );
+                os << " " << LinkageSpec::linkageName( linkage );
         } // if
-        os << " with body " << has_body() << endl;
+        os << " with body " << has_body();
 
         if ( ! parameters.empty() ) {
-                os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
-                printAll( parameters, os, indent+4 );
+                os << endl << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
         } // if
         if ( ! members.empty() ) {
-                os << endl << string( indent+2, ' ' ) << "with members" << endl;
-                printAll( members, os, indent+4 );
+                os << endl << indent << "... with members" << endl;
+                printAll( members, os, indent+1 );
         } // if
         if ( ! attributes.empty() ) {
-                os << endl << string( indent+2, ' ' ) << "with attributes" << endl;
-                printAll( attributes, os, indent+4 );
+                os << endl << indent << "... with attributes" << endl;
+                printAll( attributes, os, indent+1 );
         } // if
+        os << endl;
 }
 
-void AggregateDecl::printShort( std::ostream &os, int indent ) const {
+void AggregateDecl::printShort( std::ostream &os, Indenter indent ) const {
         using std::string;
         using std::endl;
 
-        os << typeString() << " " << get_name();
-        os << string( indent+2, ' ' ) << "with body " << has_body() << endl;
+        os << typeString() << " " << name << " with body " << has_body() << endl;
 
         if ( ! parameters.empty() ) {
-                os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
-                printAll( parameters, os, indent+4 );
+                os << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
         } // if
 }

src/SynTree/ApplicationExpr.cc

@@ -55 +55 @@
         set_result( ResolvExpr::extractResultType( function ) );
 
-        assert( has_result() );
+        assert( result );
 }
 
@@ -68 +68 @@
 }
 
-void printInferParams( const InferredParams & inferParams, std::ostream &os, int indent, int level ) {
+void printInferParams( const InferredParams & inferParams, std::ostream &os, Indenter indent, int level ) {
         if ( ! inferParams.empty() ) {
-                os << std::string(indent, ' ') << "with inferred parameters " << level << ":" << std::endl;
+                os << indent << "with inferred parameters " << level << ":" << std::endl;
                 for ( InferredParams::const_iterator i = inferParams.begin(); i != inferParams.end(); ++i ) {
-                        os << std::string(indent+2, ' ');
-                        Declaration::declFromId( i->second.decl )->printShort( os, indent+2 );
+                        os << indent+1;
+                        Declaration::declFromId( i->second.decl )->printShort( os, indent+1 );
                         os << std::endl;
-                        printInferParams( *i->second.inferParams, os, indent+2, level+1 );
+                        printInferParams( *i->second.inferParams, os, indent+1, level+1 );
                 } // for
         } // if
 }
 
-void ApplicationExpr::print( std::ostream &os, int indent ) const {
-        os << "Application of" << std::endl << std::string(indent+2, ' ');
-        function->print( os, indent+2 );
+void ApplicationExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Application of" << std::endl << indent+1;
+        function->print( os, indent+1 );
+        os << std::endl;
         if ( ! args.empty() ) {
-                os << std::string( indent, ' ' ) << "to arguments" << std::endl;
-                printAll( args, os, indent+2 );
+                os << indent << "... to arguments" << std::endl;
+                printAll( args, os, indent+1 );
         } // if
-        printInferParams( inferParams, os, indent+2, 0 );
+        printInferParams( inferParams, os, indent+1, 0 );
         Expression::print( os, indent );
 }

src/SynTree/ArrayType.cc

@@ -39 +39 @@
 }
 
-void ArrayType::print( std::ostream &os, int indent ) const {
+void ArrayType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
         if ( isStatic ) {

src/SynTree/AttrType.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// AttrType.cc.cc -- 
+// AttrType.cc.cc --
 //
 // Author           : Richard C. Bilson
@@ -42 +42 @@
 }
 
-void AttrType::print( std::ostream &os, int indent ) const {
+void AttrType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
         os << "attribute " << name << " applied to ";

src/SynTree/Attribute.cc

@@ -28 +28 @@
 }
 
-void Attribute::print( std::ostream &os, int indent ) const {
+void Attribute::print( std::ostream &os, Indenter indent ) const {
   using std::endl;
   using std::string;
@@ -36 +36 @@
     if ( ! parameters.empty() ) {
       os << " with parameters: " << endl;
-      printAll( parameters, os, indent );
+      printAll( parameters, os, indent+1 );
     }
   }

src/SynTree/Attribute.h

@@ -43 +43 @@
         bool empty() const { return name == ""; }
 
-        Attribute * clone() const { return new Attribute( *this ); }
-        virtual void accept( Visitor & v ) { v.visit( this ); }
-        virtual Attribute * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        Attribute * clone() const override { return new Attribute( *this ); }
+        virtual void accept( Visitor & v ) 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

@@ -17 +17 @@
 
 #include "Common/CodeLocation.h"
+#include "Common/Indenter.h"
 class Visitor;
 class Mutator;
@@ -29 +30 @@
         virtual void accept( Visitor & v ) = 0;
         virtual BaseSyntaxNode * acceptMutator( Mutator & m ) = 0;
-        virtual void print( std::ostream & os, int indent = 0 ) const = 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.
+        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

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// BasicType.cc -- 
+// BasicType.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 11 12:52:05 2017
-// Update Count     : 9
+// Last Modified On : Mon Sep 25 14:14:03 2017
+// Update Count     : 11
 //
 
@@ -24 +24 @@
 BasicType::BasicType( const Type::Qualifiers &tq, Kind bt, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), kind( bt ) {}
 
-void BasicType::print( std::ostream &os, int indent ) const {
+void BasicType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
         os << BasicType::typeNames[ kind ];
@@ -43 +43 @@
           case LongLongSignedInt:
           case LongLongUnsignedInt:
+          case SignedInt128:
+          case UnsignedInt128:
                 return true;
           case Float:

src/SynTree/CommaExpr.cc

@@ -21 +21 @@
 #include "Type.h"            // for Type
 
-CommaExpr::CommaExpr( Expression *arg1, Expression *arg2, Expression *_aname )
-                : Expression( _aname ), arg1( arg1 ), arg2( arg2 ) {
+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
@@ -39 +39 @@
 }
 
-void CommaExpr::print( std::ostream &os, int indent ) const {
+void CommaExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Comma Expression:" << std::endl;
-        os << std::string( indent+2, ' ' );
-        arg1->print( os, indent+2 );
+        os << (indent+1);
+        arg1->print( os, indent+1 );
         os << std::endl;
-        os << std::string( indent+2, ' ' );
-        arg2->print( os, indent+2 );
+        os << (indent+1);
+        arg2->print( os, indent+1 );
         Expression::print( os, indent );
 }

src/SynTree/CompoundStmt.cc

@@ -73 +73 @@
 }
 
-void CompoundStmt::print( std::ostream &os, int indent ) const {
-        os << "CompoundStmt" << endl ;
-        printAll( kids, os, indent + 2 );
+void CompoundStmt::print( std::ostream &os, Indenter indent ) const {
+        os << "CompoundStmt" << endl;
+        printAll( kids, os, indent+1 );
 }
 

src/SynTree/Constant.cc

@@ -71 +71 @@
 }
 
-void Constant::print( std::ostream &os ) const {
+void Constant::print( std::ostream &os, Indenter ) const {
         os << "(" << rep << " " << val.ival;
         if ( type ) {

src/SynTree/Constant.h

@@ -19 +19 @@
 #include <string>     // for string
 
+#include "BaseSyntaxNode.h"
 #include "Mutator.h"  // for Mutator
 #include "Visitor.h"  // for Visitor
@@ -24 +25 @@
 class Type;
 
-class Constant {
+class Constant : public BaseSyntaxNode {
   public:
         Constant( Type * type, std::string rep, unsigned long long val );
@@ -30 +31 @@
         Constant( const Constant & other );
         virtual ~Constant();
+
+        virtual Constant * clone() const { return new Constant( *this ); }
 
         Type * get_type() { return type; }
@@ -54 +57 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Constant * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os ) const;
+        virtual void print( std::ostream & os, Indenter indent = 0 ) const;
   private:
         Type * type;

src/SynTree/DeclStmt.cc

@@ -33 +33 @@
 }
 
-void DeclStmt::print( std::ostream &os, int indent ) const {
+void DeclStmt::print( std::ostream &os, Indenter indent ) const {
         assert( decl != 0 );
         os << "Declaration of ";

src/SynTree/Declaration.cc

@@ -42 +42 @@
 
 void Declaration::fixUniqueId() {
+        // don't need to set unique ID twice
+        if ( uniqueId ) return;
         uniqueId = ++lastUniqueId;
         idMap[ uniqueId ] = this;
@@ -70 +72 @@
 }
 
-void AsmDecl::print( std::ostream &os, int indent ) const {
+void AsmDecl::print( std::ostream &os, Indenter indent ) const {
         stmt->print( os, indent );
 }
 
-void AsmDecl::printShort( std::ostream &os, int indent ) const {
+void AsmDecl::printShort( std::ostream &os, Indenter indent ) const {
         stmt->print( os, indent );
 }

src/SynTree/Declaration.h

@@ -61 +61 @@
 
         void fixUniqueId( void );
-        virtual Declaration *clone() const = 0;
+        virtual Declaration *clone() const override = 0;
         virtual void accept( Visitor &v ) override = 0;
-        virtual Declaration *acceptMutator( Mutator &m ) = 0;
-        virtual void print( std::ostream &os, int indent = 0 ) const override = 0;
-        virtual void printShort( std::ostream &os, int indent = 0 ) const = 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 );
@@ -142 +142 @@
         virtual void accept( Visitor &v ) override { v.visit( this ); }
         virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const override;
-        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
 };
 
@@ -170 +170 @@
         virtual void accept( Visitor &v ) override { v.visit( this ); }
         virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const override;
-        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
 };
 
@@ -193 +193 @@
 
         virtual NamedTypeDecl *clone() const override = 0;
-        virtual void print( std::ostream &os, int indent = 0 ) const override;
-        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
 };
 
@@ -235 +235 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 
   private:
@@ -276 +276 @@
         AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
 
-        virtual void print( std::ostream &os, int indent = 0 ) const override;
-        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
   protected:
         virtual std::string typeString() const = 0;
@@ -355 +355 @@
         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, int indent = 0 ) const override;
-        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
 };
 

src/SynTree/Expression.cc

@@ -33 +33 @@
 #include "GenPoly/Lvalue.h"
 
-Expression::Expression( Expression *_aname ) : result( 0 ), env( 0 ), argName( _aname ) {}
-
-Expression::Expression( const Expression &other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
+Expression::Expression() : result( 0 ), env( 0 ) {}
+
+Expression::Expression( const Expression &other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), extension( other.extension ) {
 }
 
 Expression::~Expression() {
         delete env;
-        delete argName; // xxx -- there's a problem in cloning ConstantExpr I still don't know how to fix
         delete result;
 }
 
-void Expression::print( std::ostream &os, int indent ) const {
+void Expression::print( std::ostream &os, Indenter indent ) const {
         if ( env ) {
-                os << std::string( indent, ' ' ) << "with environment:" << std::endl;
-                env->print( os, indent+2 );
+                os << std::endl << indent << "... with environment:" << std::endl;
+                env->print( os, indent+1 );
         } // if
 
-        if ( argName ) {
-                os << std::string( indent, ' ' ) << "with designator:";
-                argName->print( os, indent+2 );
+        if ( extension ) {
+                os << std::endl << indent << "... with extension:";
         } // if
-
-        if ( extension ) {
-                os << std::string( indent, ' ' ) << "with extension:";
-        } // if
-}
-
-ConstantExpr::ConstantExpr( Constant _c, Expression *_aname ) : Expression( _aname ), constant( _c ) {
+}
+
+ConstantExpr::ConstantExpr( Constant _c ) : Expression(), constant( _c ) {
         set_result( constant.get_type()->clone() );
 }
@@ -69 +63 @@
 ConstantExpr::~ConstantExpr() {}
 
-void ConstantExpr::print( std::ostream &os, int indent ) const {
+void ConstantExpr::print( std::ostream &os, Indenter indent ) const {
         os << "constant expression " ;
         constant.print( os );
@@ -75 +69 @@
 }
 
-VariableExpr::VariableExpr( DeclarationWithType *_var, Expression *_aname ) : Expression( _aname ), var( _var ) {
+VariableExpr::VariableExpr( DeclarationWithType *_var ) : Expression(), var( _var ) {
         assert( var );
         assert( var->get_type() );
@@ -96 +90 @@
 }
 
-void VariableExpr::print( std::ostream &os, int indent ) const {
+void VariableExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Variable Expression: ";
-
-        Declaration *decl = get_var();
-        if ( decl != 0) decl->printShort(os, indent + 2);
-        os << std::endl;
-        Expression::print( os, indent );
-}
-
-SizeofExpr::SizeofExpr( Expression *expr_, Expression *_aname ) :
-                Expression( _aname ), expr(expr_), type(0), isType(false) {
+        var->printShort(os, indent);
+        Expression::print( os, indent );
+}
+
+SizeofExpr::SizeofExpr( Expression *expr_ ) :
+                Expression(), expr(expr_), type(0), isType(false) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
-SizeofExpr::SizeofExpr( Type *type_, Expression *_aname ) :
-                Expression( _aname ), expr(0), type(type_), isType(true) {
+SizeofExpr::SizeofExpr( Type *type_ ) :
+                Expression(), expr(0), type(type_), isType(true) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
@@ -124 +115 @@
 }
 
-void SizeofExpr::print( std::ostream &os, int indent) const {
+void SizeofExpr::print( std::ostream &os, Indenter indent) const {
         os << "Sizeof Expression on: ";
-
-        if (isType)
-                type->print(os, indent + 2);
-        else
-                expr->print(os, indent + 2);
-
-        os << std::endl;
-        Expression::print( os, indent );
-}
-
-AlignofExpr::AlignofExpr( Expression *expr_, Expression *_aname ) :
-                Expression( _aname ), expr(expr_), type(0), isType(false) {
+        if (isType) type->print(os, indent+1);
+        else expr->print(os, indent+1);
+        Expression::print( os, indent );
+}
+
+AlignofExpr::AlignofExpr( Expression *expr_ ) :
+                Expression(), expr(expr_), type(0), isType(false) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
-AlignofExpr::AlignofExpr( Type *type_, Expression *_aname ) :
-                Expression( _aname ), expr(0), type(type_), isType(true) {
+AlignofExpr::AlignofExpr( Type *type_ ) :
+                Expression(), expr(0), type(type_), isType(true) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
@@ -155 +141 @@
 }
 
-void AlignofExpr::print( std::ostream &os, int indent) const {
+void AlignofExpr::print( std::ostream &os, Indenter indent) const {
         os << "Alignof Expression on: ";
-
-        if (isType)
-                type->print(os, indent + 2);
-        else
-                expr->print(os, indent + 2);
-
-        os << std::endl;
-        Expression::print( os, indent );
-}
-
-UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type_, const std::string &member_, Expression *_aname ) :
-                Expression( _aname ), type(type_), member(member_) {
+        if (isType) type->print(os, indent+1);
+        else expr->print(os, indent+1);
+        Expression::print( os, indent );
+}
+
+UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type, const std::string &member ) :
+                Expression(), type(type), member(member) {
+        assert( type );
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
@@ -179 +161 @@
 }
 
-void UntypedOffsetofExpr::print( std::ostream &os, int indent) const {
-        os << std::string( indent, ' ' ) << "Untyped Offsetof Expression on member " << member << " of ";
-
-        if ( type ) {
-                type->print(os, indent + 2);
-        } else {
-                os << "<NULL>";
-        }
-
-        os << std::endl;
-        Expression::print( os, indent );
-}
-
-OffsetofExpr::OffsetofExpr( Type *type_, DeclarationWithType *member_, Expression *_aname ) :
-                Expression( _aname ), type(type_), member(member_) {
+void UntypedOffsetofExpr::print( std::ostream &os, Indenter indent) const {
+        os << "Untyped Offsetof Expression on member " << member << " of ";
+        type->print(os, indent+1);
+        Expression::print( os, indent );
+}
+
+OffsetofExpr::OffsetofExpr( Type *type, DeclarationWithType *member ) :
+                Expression(), type(type), member(member) {
+        assert( member );
+        assert( type );
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
@@ -204 +181 @@
 }
 
-void OffsetofExpr::print( std::ostream &os, int indent) const {
-        os << std::string( indent, ' ' ) << "Offsetof Expression on member ";
-
-        if ( member ) {
-                os << member->get_name();
-        } else {
-                os << "<NULL>";
-        }
-
-        os << " of ";
-
-        if ( type ) {
-                type->print(os, indent + 2);
-        } else {
-                os << "<NULL>";
-        }
-
-        os << std::endl;
-        Expression::print( os, indent );
-}
-
-OffsetPackExpr::OffsetPackExpr( StructInstType *type_, Expression *aname_ ) : Expression( aname_ ), type( type_ ) {
+void OffsetofExpr::print( std::ostream &os, Indenter indent) const {
+        os << "Offsetof Expression on member " << member->name << " of ";
+        type->print(os, indent+1);
+        Expression::print( os, indent );
+}
+
+OffsetPackExpr::OffsetPackExpr( StructInstType *type ) : Expression(), type( type ) {
+        assert( type );
         set_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
 }
@@ -233 +196 @@
 OffsetPackExpr::~OffsetPackExpr() { delete type; }
 
-void OffsetPackExpr::print( std::ostream &os, int indent ) const {
-        os << std::string( indent, ' ' ) << "Offset pack expression on ";
-
-        if ( type ) {
-                type->print(os, indent + 2);
-        } else {
-                os << "<NULL>";
-        }
-
-        os << std::endl;
-        Expression::print( os, indent );
-}
-
-AttrExpr::AttrExpr( Expression *attr, Expression *expr_, Expression *_aname ) :
-                Expression( _aname ), attr( attr ), expr(expr_), type(0), isType(false) {
-}
-
-AttrExpr::AttrExpr( Expression *attr, Type *type_, Expression *_aname ) :
-                Expression( _aname ), attr( attr ), expr(0), type(type_), isType(true) {
+void OffsetPackExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Offset pack expression on ";
+        type->print(os, indent+1);
+        Expression::print( os, indent );
+}
+
+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) {
 }
 
@@ -264 +220 @@
 }
 
-void AttrExpr::print( std::ostream &os, int indent) const {
+void AttrExpr::print( std::ostream &os, Indenter indent) const {
         os << "Attr ";
-        attr->print( os, indent + 2 );
+        attr->print( os, indent+1);
         if ( isType || expr ) {
                 os << "applied to: ";
-
-                if (isType)
-                        type->print(os, indent + 2);
-                else
-                        expr->print(os, indent + 2);
+                if (isType) type->print(os, indent+1);
+                else expr->print(os, indent+1);
         } // if
-
-        os << std::endl;
-        Expression::print( os, indent );
-}
-
-CastExpr::CastExpr( Expression *arg_, Type *toType, Expression *_aname ) : Expression( _aname ), arg(arg_) {
+        Expression::print( os, indent );
+}
+
+CastExpr::CastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
         set_result(toType);
 }
 
-CastExpr::CastExpr( Expression *arg_, Expression *_aname ) : Expression( _aname ), arg(arg_) {
+CastExpr::CastExpr( Expression *arg_ ) : Expression(), arg(arg_) {
         set_result( new VoidType( Type::Qualifiers() ) );
 }
@@ -295 +246 @@
 }
 
-void CastExpr::print( std::ostream &os, int indent ) const {
-        os << "Cast of:" << std::endl << std::string( indent+2, ' ' );
-        arg->print(os, indent+2);
-        os << std::endl << std::string( indent, ' ' ) << "to:" << std::endl;
-        os << std::string( indent+2, ' ' );
+void CastExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Cast of:" << std::endl << indent+1;
+        arg->print(os, indent+1);
+        os << std::endl << indent << "... to:";
         if ( result->isVoid() ) {
-                os << "nothing";
+                os << " nothing";
         } else {
-                result->print( os, indent+2 );
+                os << std::endl << indent+1;
+                result->print( os, indent+1 );
         } // if
-        os << std::endl;
         Expression::print( os, indent );
 }
@@ -320 +270 @@
 }
 
-void VirtualCastExpr::print( std::ostream &os, int indent ) const {
-        os << "Virtual Cast of:" << std::endl << std::string( indent+2, ' ' );
-        arg->print(os, indent+2);
-        os << std::endl << std::string( indent, ' ' ) << "to:" << std::endl;
-        os << std::string( indent+2, ' ' );
+void VirtualCastExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Virtual Cast of:" << std::endl << indent+1;
+        arg->print(os, indent+1);
+        os << std::endl << indent << "... to:";
         if ( ! result ) {
-                os << "unknown";
+                os << " unknown";
         } else {
-                result->print( os, indent+2 );
+                os << std::endl << indent+1;
+                result->print( os, indent+1 );
         } // if
-        os << std::endl;
-        Expression::print( os, indent );
-}
-
-UntypedMemberExpr::UntypedMemberExpr( Expression * _member, Expression *_aggregate, Expression *_aname ) :
-                Expression( _aname ), member(_member), aggregate(_aggregate) {}
+        Expression::print( os, indent );
+}
+
+UntypedMemberExpr::UntypedMemberExpr( Expression * member, Expression *aggregate ) :
+                Expression(), member(member), aggregate(aggregate) {
+        assert( aggregate );
+}
 
 UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr &other ) :
@@ -346 +297 @@
 }
 
-void UntypedMemberExpr::print( std::ostream &os, int indent ) const {
-        os << "Untyped Member Expression, with field: " << std::endl;
-        os << std::string( indent+2, ' ' );
-        get_member()->print(os, indent+4);
-        os << std::string( indent+2, ' ' );
-
-        Expression *agg = get_aggregate();
-        os << "from aggregate: " << std::endl;
-        if (agg != 0) {
-                os << std::string( indent + 4, ' ' );
-                agg->print(os, indent + 4);
-        }
-        os << std::string( indent+2, ' ' );
+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;
+        aggregate->print(os, indent+1);
         Expression::print( os, indent );
 }
@@ -377 +320 @@
 
 
-MemberExpr::MemberExpr( DeclarationWithType *_member, Expression *_aggregate, Expression *_aname ) :
-                Expression( _aname ), member(_member), aggregate(_aggregate) {
+MemberExpr::MemberExpr( DeclarationWithType *member, Expression *aggregate ) :
+                Expression(), member(member), aggregate(aggregate) {
+        assert( member );
+        assert( aggregate );
 
         TypeSubstitution sub( makeSub( aggregate->get_result() ) );
@@ -396 +341 @@
 }
 
-void MemberExpr::print( std::ostream &os, int indent ) const {
+void MemberExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Member Expression, with field: " << std::endl;
-
-        assert( member );
-        os << std::string( indent + 2, ' ' );
-        member->print( os, indent + 2 );
-        os << std::endl;
-
-        Expression *agg = get_aggregate();
-        os << std::string( indent, ' ' ) << "from aggregate: " << std::endl;
-        if (agg != 0) {
-                os << std::string( indent + 2, ' ' );
-                agg->print(os, indent + 2);
-        }
-        os << std::string( indent+2, ' ' );
-        Expression::print( os, indent );
-}
-
-UntypedExpr::UntypedExpr( Expression *_function, const std::list<Expression *> &_args, Expression *_aname ) :
-                Expression( _aname ), function(_function), args(_args) {}
+        os << indent+1;
+        member->print( os, 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 ) :
+                Expression(), function(function), args(args) {}
 
 UntypedExpr::UntypedExpr( const UntypedExpr &other ) :
@@ -456 +392 @@
 
 
-void UntypedExpr::print( std::ostream &os, int indent ) const {
+void UntypedExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Applying untyped: " << std::endl;
-        os << std::string( indent+2, ' ' );
-        function->print(os, indent + 2);
-        os << std::string( indent, ' ' ) << "...to: " << std::endl;
-        printAll(args, os, indent + 2);
-        Expression::print( os, indent );
-}
-
-void UntypedExpr::printArgs( std::ostream &os, int indent ) const {
-        std::list<Expression *>::const_iterator i;
-        for (i = args.begin(); i != args.end(); i++) {
-                os << std::string(indent, ' ' );
-                (*i)->print(os, indent);
-        }
-}
-
-NameExpr::NameExpr( std::string _name, Expression *_aname ) : Expression( _aname ), name(_name) {
-        assertf(_name != "0", "Zero is not a valid name\n");
-        assertf(_name != "1", "One is not a valid name\n");
+        os << indent+1;
+        function->print(os, indent+1);
+        os << std::endl << indent << "...to: " << std::endl;
+        printAll(args, os, indent+1);
+        Expression::print( os, indent );
+}
+
+NameExpr::NameExpr( std::string name ) : Expression(), name(name) {
+        assertf(name != "0", "Zero is not a valid name");
+        assertf(name != "1", "One is not a valid name");
 }
 
@@ -483 +411 @@
 NameExpr::~NameExpr() {}
 
-void NameExpr::print( std::ostream &os, int indent ) const {
-        os << "Name: " << get_name() << std::endl;
-        Expression::print( os, indent );
-}
-
-LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp, Expression *_aname ) :
-                Expression( _aname ), arg1(arg1_), arg2(arg2_), isAnd(andp) {
+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 ) :
+                Expression(), arg1(arg1_), arg2(arg2_), isAnd(andp) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
 }
@@ -502 +430 @@
 }
 
-void LogicalExpr::print( std::ostream &os, int indent )const {
-        os << "Short-circuited operation (" << (isAnd?"and":"or") << ") on: ";
+void LogicalExpr::print( std::ostream &os, Indenter indent )const {
+        os << "Short-circuited operation (" << (isAnd ? "and" : "or") << ") on: ";
         arg1->print(os);
         os << " and ";
         arg2->print(os);
-        os << std::endl;
-        Expression::print( os, indent );
-}
-
-ConditionalExpr::ConditionalExpr( Expression *arg1_, Expression *arg2_, Expression *arg3_, Expression *_aname ) :
-                Expression( _aname ), arg1(arg1_), arg2(arg2_), arg3(arg3_) {}
+        Expression::print( os, indent );
+}
+
+ConditionalExpr::ConditionalExpr( Expression * arg1, Expression * arg2, Expression * arg3 ) :
+                Expression(), arg1(arg1), arg2(arg2), arg3(arg3) {}
 
 ConditionalExpr::ConditionalExpr( const ConditionalExpr &other ) :
@@ -524 +451 @@
 }
 
-void ConditionalExpr::print( std::ostream &os, int indent ) const {
-        os << "Conditional expression on: " << std::endl;
-        os << std::string( indent+2, ' ' );
-        arg1->print( os, indent+2 );
-        os << std::string( indent, ' ' ) << "First alternative:" << std::endl;
-        os << std::string( indent+2, ' ' );
-        arg2->print( os, indent+2 );
-        os << std::string( indent, ' ' ) << "Second alternative:" << std::endl;
-        os << std::string( indent+2, ' ' );
-        arg3->print( os, indent+2 );
-        os << std::endl;
+void ConditionalExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Conditional expression on: " << std::endl << indent+1;
+        arg1->print( os, indent+1 );
+        os << indent << "First alternative:" << std::endl << indent+1;
+        arg2->print( os, indent+1 );
+        os << indent << "Second alternative:" << std::endl << indent+1;
+        arg3->print( os, indent+1 );
         Expression::print( os, indent );
 }
@@ -541 +464 @@
 
 
-void AsmExpr::print( std::ostream &os, int indent ) const {
+void AsmExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Asm Expression: " << std::endl;
-        if ( inout ) inout->print( os, indent + 2 );
-        if ( constraint ) constraint->print( os, indent + 2 );
-        if ( operand ) operand->print( os, indent + 2 );
+        if ( inout ) inout->print( os, indent+1 );
+        if ( constraint ) constraint->print( os, indent+1 );
+        if ( operand ) operand->print( os, indent+1 );
 }
 
@@ -551 +474 @@
 ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( ApplicationExpr * callExpr ) : callExpr( callExpr ) {
         assert( callExpr );
-        assert( callExpr->has_result() );
+        assert( callExpr->result );
         set_result( callExpr->get_result()->clone() );
 }
@@ -569 +492 @@
 }
 
-void ImplicitCopyCtorExpr::print( std::ostream &os, int indent ) const {
-        os <<  "Implicit Copy Constructor Expression: " << std::endl;
-        assert( callExpr );
-        os << std::string( indent+2, ' ' );
-        callExpr->print( os, indent + 2 );
-        os << std::endl << std::string( indent, ' ' ) << "with temporaries:" << std::endl;
-        printAll(tempDecls, os, indent+2);
-        os << std::endl << std::string( indent, ' ' ) << "with return temporaries:" << std::endl;
-        printAll(returnDecls, os, indent+2);
+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 );
 }
@@ -587 +508 @@
         Expression * arg = InitTweak::getCallArg( callExpr, 0 );
         assert( arg );
-        set_result( maybeClone( arg->get_result() ) );
+        set_result( maybeClone( arg->result ) );
 }
 
@@ -597 +518 @@
 }
 
-void ConstructorExpr::print( std::ostream &os, int indent ) const {
-        os <<  "Constructor Expression: " << std::endl;
-        assert( callExpr );
-        os << std::string( indent+2, ' ' );
+void ConstructorExpr::print( std::ostream &os, Indenter indent ) const {
+        os <<  "Constructor Expression: " << std::endl << indent+1;
         callExpr->print( os, indent + 2 );
         Expression::print( os, indent );
@@ -618 +537 @@
 }
 
-void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
-        os << "Compound Literal Expression: " << std::endl;
-        os << std::string( indent+2, ' ' );
-        get_result()->print( os, indent + 2 );
-        os << std::string( indent+2, ' ' );
-        initializer->print( os, indent + 2 );
+void CompoundLiteralExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Compound Literal Expression: " << std::endl << indent+1;
+        result->print( os, indent+1 );
+        os << indent+1;
+        initializer->print( os, indent+1 );
         Expression::print( os, indent );
 }
@@ -629 +547 @@
 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, int indent ) const {
+void RangeExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Range Expression: ";
         low->print( os, indent );
@@ -659 +577 @@
         deleteAll( returnDecls );
 }
-void StmtExpr::print( std::ostream &os, int indent ) const {
-        os << "Statement Expression: " << std::endl << std::string( indent, ' ' );
-        statements->print( os, indent+2 );
+void StmtExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Statement Expression: " << std::endl << indent+1;
+        statements->print( os, indent+1 );
         if ( ! returnDecls.empty() ) {
-                os << std::string( indent+2, ' ' ) << "with returnDecls: ";
-                printAll( returnDecls, os, indent+2 );
+                os << indent+1 << "... with returnDecls: ";
+                printAll( returnDecls, os, indent+1 );
         }
         if ( ! dtors.empty() ) {
-                os << std::string( indent+2, ' ' ) << "with dtors: ";
-                printAll( dtors, os, indent+2 );
+                os << indent+1 << "... with dtors: ";
+                printAll( dtors, os, indent+1 );
         }
         Expression::print( os, indent );
@@ -690 +608 @@
         delete var;
 }
-void UniqueExpr::print( std::ostream &os, int indent ) const {
-        os << "Unique Expression with id:" << id << std::endl << std::string( indent+2, ' ' );
-        get_expr()->print( os, indent+2 );
-        if ( get_object() ) {
-                os << std::string( indent+2, ' ' ) << "with decl: ";
-                get_object()->printShort( os, indent+2 );
+void UniqueExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Unique Expression with id:" << id << std::endl << indent+1;
+        expr->print( os, indent+1 );
+        if ( object ) {
+                os << indent << "... with decl: ";
+                get_object()->printShort( os, indent+1 );
         }
         Expression::print( os, indent );
@@ -713 +631 @@
 }
 
-void UntypedInitExpr::print( std::ostream & os, int indent ) const {
-        os << "Untyped Init Expression" << std::endl << std::string( indent+2, ' ' );
-        expr->print( os, indent+2 );
+void UntypedInitExpr::print( std::ostream & os, Indenter indent ) const {
+        os << "Untyped Init Expression" << std::endl << indent+1;
+        expr->print( os, indent+1 );
         if ( ! initAlts.empty() ) {
                 for ( const InitAlternative & alt : initAlts ) {
-                        os << std::string( indent+2, ' ' ) <<  "InitAlternative: ";
-                        alt.type->print( os, indent+2 );
-                        alt.designation->print( os, indent+2 );
+                        os << indent+1 <<  "InitAlternative: ";
+                        alt.type->print( os, indent+1 );
+                        alt.designation->print( os, indent+1 );
                 }
         }
@@ -734 +652 @@
 }
 
-void InitExpr::print( std::ostream & os, int indent ) const {
-        os << "Init Expression" << std::endl << std::string( indent+2, ' ' );
-        expr->print( os, indent+2 );
-        os << std::string( indent+2, ' ' ) << "with designation: ";
-        designation->print( os, indent+2 );
+void InitExpr::print( std::ostream & os, Indenter indent ) const {
+        os << "Init Expression" << std::endl << indent+1;
+        expr->print( os, indent+1 );
+        os << indent+1 << "... with designation: ";
+        designation->print( os, indent+1 );
 }
 

src/SynTree/Expression.h

@@ -36 +36 @@
         Type * result;
         TypeSubstitution * env;
-        Expression * argName; // if expression is used as an argument, it can be "designated" by this name
         bool extension = false;
 
-        Expression( Expression * _aname = nullptr );
+        Expression();
         Expression( const Expression & other );
         virtual ~Expression();
@@ -46 +45 @@
         const Type * get_result() const { return result; }
         void set_result( Type * newValue ) { result = newValue; }
-        bool has_result() const { return result != nullptr; }
 
         TypeSubstitution * get_env() const { return env; }
         void set_env( TypeSubstitution * newValue ) { env = newValue; }
-        Expression * get_argName() const { return argName; }
-        void set_argName( Expression * name ) { argName = name; }
         bool get_extension() const { return extension; }
         Expression * set_extension( bool exten ) { extension = exten; return this; }
 
-        virtual Expression * clone() const = 0;
-        virtual void accept( Visitor & v ) = 0;
-        virtual Expression * acceptMutator( Mutator & m ) = 0;
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual Expression * clone() const override = 0;
+        virtual void accept( Visitor & v ) override = 0;
+        virtual Expression * acceptMutator( Mutator & m ) override = 0;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -101 +97 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -112 +108 @@
         std::list<Expression*> args;
 
-        UntypedExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >(), Expression *_aname = nullptr );
+        UntypedExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >() );
         UntypedExpr( const UntypedExpr & other );
         virtual ~UntypedExpr();
@@ -119 +115 @@
         void set_function( Expression * newValue ) { function = newValue; }
 
-        void set_args( std::list<Expression *> & listArgs ) { args = listArgs; }
         std::list<Expression*>::iterator begin_args() { return args.begin(); }
         std::list<Expression*>::iterator end_args() { return args.end(); }
@@ -130 +125 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
-        virtual void printArgs(std::ostream & os, int indent = 0) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -139 +133 @@
         std::string name;
 
-        NameExpr( std::string name, Expression *_aname = nullptr );
+        NameExpr( std::string name );
         NameExpr( const NameExpr & other );
         virtual ~NameExpr();
@@ -149 +143 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -160 +154 @@
         Expression * arg;
 
-        AddressExpr( Expression * arg, Expression *_aname = nullptr );
+        AddressExpr( Expression * arg );
         AddressExpr( const AddressExpr & other );
         virtual ~AddressExpr();
@@ -170 +164 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -186 +180 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -194 +188 @@
         Expression * arg;
 
-        CastExpr( Expression * arg, Expression *_aname = nullptr );
-        CastExpr( Expression * arg, Type * toType, Expression *_aname = nullptr );
+        CastExpr( Expression * arg );
+        CastExpr( Expression * arg, Type * toType );
         CastExpr( const CastExpr & other );
         virtual ~CastExpr();
@@ -205 +199 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -223 +217 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -232 +226 @@
         Expression * aggregate;
 
-        UntypedMemberExpr( Expression * member, Expression * aggregate, Expression *_aname = nullptr );
+        UntypedMemberExpr( Expression * member, Expression * aggregate );
         UntypedMemberExpr( const UntypedMemberExpr & other );
         virtual ~UntypedMemberExpr();
@@ -244 +238 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -254 +248 @@
         Expression * aggregate;
 
-        MemberExpr( DeclarationWithType * member, Expression * aggregate, Expression *_aname = nullptr );
+        MemberExpr( DeclarationWithType * member, Expression * aggregate );
         MemberExpr( const MemberExpr & other );
         virtual ~MemberExpr();
@@ -266 +260 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -275 +269 @@
         DeclarationWithType * var;
 
-        VariableExpr( DeclarationWithType * var, Expression *_aname = nullptr );
+        VariableExpr( DeclarationWithType * var );
         VariableExpr( const VariableExpr & other );
         virtual ~VariableExpr();
@@ -287 +281 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -295 +289 @@
         Constant constant;
 
-        ConstantExpr( Constant constant, Expression *_aname = nullptr );
+        ConstantExpr( Constant constant );
         ConstantExpr( const ConstantExpr & other );
         virtual ~ConstantExpr();
@@ -305 +299 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -315 +309 @@
         bool isType;
 
-        SizeofExpr( Expression * expr, Expression *_aname = nullptr );
+        SizeofExpr( Expression * expr );
         SizeofExpr( const SizeofExpr & other );
-        SizeofExpr( Type * type, Expression *_aname = nullptr );
+        SizeofExpr( Type * type );
         virtual ~SizeofExpr();
 
@@ -330 +324 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -340 +334 @@
         bool isType;
 
-        AlignofExpr( Expression * expr, Expression *_aname = nullptr );
+        AlignofExpr( Expression * expr );
         AlignofExpr( const AlignofExpr & other );
-        AlignofExpr( Type * type, Expression *_aname = nullptr );
+        AlignofExpr( Type * type );
         virtual ~AlignofExpr();
 
@@ -355 +349 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -364 +358 @@
         std::string member;
 
-        UntypedOffsetofExpr( Type * type, const std::string & member, Expression *_aname = nullptr );
+        UntypedOffsetofExpr( Type * type, const std::string & member );
         UntypedOffsetofExpr( const UntypedOffsetofExpr & other );
         virtual ~UntypedOffsetofExpr();
@@ -376 +370 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -385 +379 @@
         DeclarationWithType * member;
 
-        OffsetofExpr( Type * type, DeclarationWithType * member, Expression *_aname = nullptr );
+        OffsetofExpr( Type * type, DeclarationWithType * member );
         OffsetofExpr( const OffsetofExpr & other );
         virtual ~OffsetofExpr();
@@ -397 +391 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -405 +399 @@
         StructInstType * type;
 
-        OffsetPackExpr( StructInstType * type_, Expression * aname_ = 0 );
+        OffsetPackExpr( StructInstType * type );
         OffsetPackExpr( const OffsetPackExpr & other );
         virtual ~OffsetPackExpr();
@@ -415 +409 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -426 +420 @@
         bool isType;
 
-        AttrExpr(Expression * attr, Expression * expr, Expression *_aname = nullptr );
+        AttrExpr(Expression * attr, Expression * expr );
         AttrExpr( const AttrExpr & other );
-        AttrExpr( Expression * attr, Type * type, Expression *_aname = nullptr );
+        AttrExpr( Expression * attr, Type * type );
         virtual ~AttrExpr();
 
@@ -443 +437 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -452 +446 @@
         Expression * arg2;
 
-        LogicalExpr( Expression * arg1, Expression * arg2, bool andp = true, Expression *_aname = nullptr );
+        LogicalExpr( Expression * arg1, Expression * arg2, bool andp = true );
         LogicalExpr( const LogicalExpr & other );
         virtual ~LogicalExpr();
@@ -465 +459 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 
   private:
@@ -478 +472 @@
         Expression * arg3;
 
-        ConditionalExpr( Expression * arg1, Expression * arg2, Expression * arg3, Expression *_aname = nullptr );
+        ConditionalExpr( Expression * arg1, Expression * arg2, Expression * arg3 );
         ConditionalExpr( const ConditionalExpr & other );
         virtual ~ConditionalExpr();
@@ -492 +486 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -501 +495 @@
         Expression * arg2;
 
-        CommaExpr( Expression * arg1, Expression * arg2, Expression *_aname = nullptr );
+        CommaExpr( Expression * arg1, Expression * arg2 );
         CommaExpr( const CommaExpr & other );
         virtual ~CommaExpr();
@@ -513 +507 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -531 +525 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -557 +551 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 
         // https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints
@@ -585 +579 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -603 +597 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -621 +615 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -640 +634 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -648 +642 @@
         std::list<Expression*> exprs;
 
-        UntypedTupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
+        UntypedTupleExpr( const std::list< Expression * > & exprs );
         UntypedTupleExpr( const UntypedTupleExpr & other );
         virtual ~UntypedTupleExpr();
@@ -657 +651 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -665 +659 @@
         std::list<Expression*> exprs;
 
-        TupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
+        TupleExpr( const std::list< Expression * > & exprs );
         TupleExpr( const TupleExpr & other );
         virtual ~TupleExpr();
@@ -674 +668 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -695 +689 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -703 +697 @@
         StmtExpr * stmtExpr = nullptr;
 
-        TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname = nullptr );
+        TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls );
         TupleAssignExpr( const TupleAssignExpr & other );
         virtual ~TupleAssignExpr();
@@ -713 +707 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -736 +730 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -763 +757 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 
 private:
@@ -797 +791 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -818 +812 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 

src/SynTree/FunctionDecl.cc

@@ -63 +63 @@
 }
 
-void FunctionDecl::print( std::ostream &os, int indent ) const {
+void FunctionDecl::print( std::ostream &os, Indenter indent ) const {
         using std::endl;
         using std::string;
 
-        if ( get_name() != "" ) {
-                os << get_name() << ": ";
+        if ( name != "" ) {
+                os << name << ": ";
         } // if
-        if ( get_linkage() != LinkageSpec::Cforall ) {
-                os << LinkageSpec::linkageName( get_linkage() ) << " ";
+        if ( linkage != LinkageSpec::Cforall ) {
+                os << LinkageSpec::linkageName( linkage ) << " ";
         } // if
 
-        printAll( get_attributes(), os, indent );
+        printAll( attributes, os, indent );
 
         get_storageClasses().print( os );
         get_funcSpec().print( os );
 
-        if ( get_type() ) {
-                get_type()->print( os, indent );
+        if ( type ) {
+                type->print( os, indent );
         } else {
                 os << "untyped entity ";
@@ -86 +86 @@
 
         if ( statements ) {
-                os << string( indent + 2, ' ' ) << "with body " << endl;
-                os << string( indent + 4, ' ' );
-                statements->print( os, indent + 4 );
+                os << indent << "... with body " << endl << indent+1;
+                statements->print( os, indent+1 );
         } // if
 }
 
-void FunctionDecl::printShort( std::ostream &os, int indent ) const {
+void FunctionDecl::printShort( std::ostream &os, Indenter indent ) const {
         using std::endl;
         using std::string;
 
-        if ( get_name() != "" ) {
-                os << get_name() << ": ";
+        if ( name != "" ) {
+                os << name << ": ";
         } // if
-
-        // xxx - should printShort print attributes?
 
         get_storageClasses().print( os );
         get_funcSpec().print( os );
 
-        if ( get_type() ) {
-                get_type()->print( os, indent );
+        if ( type ) {
+                type->print( os, indent );
         } else {
                 os << "untyped entity ";

src/SynTree/FunctionType.cc

@@ -51 +51 @@
 }
 
-void FunctionType::print( std::ostream &os, int indent ) const {
+void FunctionType::print( std::ostream &os, Indenter indent ) const {
         using std::string;
         using std::endl;
@@ -58 +58 @@
         os << "function" << endl;
         if ( ! parameters.empty() ) {
-                os << string( indent + 2, ' ' ) << "with parameters" << endl;
-                printAll( parameters, os, indent + 4 );
+                os << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
                 if ( isVarArgs ) {
-                        os << string( indent + 4, ' ' ) << "and a variable number of other arguments" << endl;
+                        os << indent+1 << "and a variable number of other arguments" << endl;
                 } // if
         } else if ( isVarArgs ) {
-                os << string( indent + 4, ' ' ) << "accepting unspecified arguments" << endl;
+                os << indent+1 << "accepting unspecified arguments" << endl;
         } // if
-        os << string( indent + 2, ' ' ) << "returning ";
+        os << indent << "... returning ";
         if ( returnVals.empty() ) {
-                os << endl << string( indent + 4, ' ' ) << "nothing " << endl;
+                os << "nothing " << endl;
         } else {
                 os << endl;
-                printAll( returnVals, os, indent + 4 );
+                printAll( returnVals, os, indent+1 );
         } // if
 }

src/SynTree/Initializer.cc

@@ -38 +38 @@
 }
 
-void Designation::print( std::ostream &os, int indent ) const {
+void Designation::print( std::ostream &os, Indenter indent ) const {
         if ( ! designators.empty() ) {
-                os << std::string(indent + 2, ' ' ) << "designated by: " << std::endl;
-                for ( std::list < Expression * >::const_iterator i = designators.begin(); i != designators.end(); i++ ) {
-                        os << std::string(indent + 4, ' ' );
-                        ( *i )->print(os, indent + 4 );
+                os << "... designated by: " << std::endl;
+                for ( const Expression * d : designators ) {
+                        os << indent+1;
+                        d->print(os, indent+1 );
+                        os << std::endl;
                 }
-                os << std::endl;
         } // if
 }
@@ -64 +64 @@
 }
 
-void SingleInit::print( std::ostream &os, int indent ) const {
-        os << std::string(indent, ' ' ) << "Simple Initializer: " << std::endl;
-        os << std::string(indent+4, ' ' );
-        value->print( os, indent+4 );
+void SingleInit::print( std::ostream &os, Indenter indent ) const {
+        os << "Simple Initializer: ";
+        value->print( os, indent );
 }
 
@@ -93 +92 @@
 }
 
-void ListInit::print( std::ostream &os, int indent ) const {
-        os << std::string(indent, ' ') << "Compound initializer:  " << std::endl;
-        for ( Designation * d : designations ) {
-                d->print( os, indent + 2 );
-        }
-
-        for ( const Initializer * init : initializers ) {
-                init->print( os, indent + 2 );
+void ListInit::print( std::ostream &os, Indenter indent ) const {
+        os << "Compound initializer: " << std::endl;
+        for ( auto p : group_iterate( designations, initializers ) ) {
+                const Designation * d = std::get<0>(p);
+                const Initializer * init = std::get<1>(p);
+                os << indent+1;
+                init->print( os, indent+1 );
                 os << std::endl;
+                if ( ! d->designators.empty() ) {
+                        os << indent+1;
+                        d->print( os, indent+1 );
+                }
         }
 }
@@ -116 +118 @@
 }
 
-void ConstructorInit::print( std::ostream &os, int indent ) const {
-        os << std::endl << std::string(indent, ' ') << "Constructor initializer: " << std::endl;
+void ConstructorInit::print( std::ostream &os, Indenter indent ) const {
+        os << "Constructor initializer: " << std::endl;
         if ( ctor ) {
-                os << std::string(indent+2, ' ');
-                os << "initially constructed with ";
-                ctor->print( os, indent+4 );
+                os << indent << "... initially constructed with ";
+                ctor->print( os, indent+1 );
         } // if
 
         if ( dtor ) {
-                os << std::string(indent+2, ' ');
-                os << "destructed with ";
-                dtor->print( os, indent+4 );
+                os << indent << "... destructed with ";
+                dtor->print( os, indent+1 );
         }
 
         if ( init ) {
-                os << std::string(indent+2, ' ');
-                os << "with fallback C-style initializer: ";
-                init->print( os, indent+4 );
+                os << indent << "... with fallback C-style initializer: ";
+                init->print( os, indent+1 );
         }
 }

src/SynTree/Initializer.h

@@ -37 +37 @@
         std::list< Expression * > & get_designators() { return designators; }
 
-        virtual Designation * clone() const { return new Designation( *this ); };
+        virtual Designation * clone() const override { return new Designation( *this ); };
         virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Designation * acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual Designation * acceptMutator( Mutator &m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 
@@ -54 +54 @@
         bool get_maybeConstructed() { return maybeConstructed; }
 
-        virtual Initializer *clone() const = 0;
+        virtual Initializer *clone() const override = 0;
         virtual void accept( Visitor &v ) override = 0;
-        virtual Initializer *acceptMutator( Mutator &m ) = 0;
-        virtual void print( std::ostream &os, int indent = 0 ) const override = 0;
+        virtual Initializer *acceptMutator( Mutator &m ) override = 0;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override = 0;
   private:
         bool maybeConstructed;
@@ -78 +78 @@
         virtual void accept( Visitor &v ) override { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 
@@ -106 +106 @@
         virtual void accept( Visitor &v ) override { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 
@@ -135 +135 @@
         virtual void accept( Visitor &v ) override { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 
   private:

src/SynTree/Mutator.cc

@@ -626 +626 @@
 }
 
+TypeSubstitution * Mutator::mutate( TypeSubstitution * sub ) {
+        for ( auto & p : sub->typeEnv ) {
+                p.second = maybeMutate( p.second, *this );
+        }
+        for ( auto & p : sub->varEnv ) {
+                p.second = maybeMutate( p.second, *this );
+        }
+        return sub;
+}
+
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Mutator.h

@@ -117 +117 @@
 
         virtual Attribute * mutate( Attribute * attribute );
+
+        virtual TypeSubstitution * mutate( TypeSubstitution * sub );
+
   private:
         virtual Declaration * handleAggregateDecl(AggregateDecl * aggregateDecl );

src/SynTree/NamedTypeDecl.cc

@@ -38 +38 @@
 }
 
-void NamedTypeDecl::print( std::ostream &os, int indent ) const {
+void NamedTypeDecl::print( std::ostream &os, Indenter indent ) const {
         using namespace std;
 
-        if ( get_name() != "" ) {
-                os << get_name() << ": ";
-        } // if
-        if ( get_linkage() != LinkageSpec::Cforall ) {
-                os << LinkageSpec::linkageName( get_linkage() ) << " ";
+        if ( name != "" ) os << name << ": ";
+
+        if ( linkage != LinkageSpec::Cforall ) {
+                os << LinkageSpec::linkageName( linkage ) << " ";
         } // if
         get_storageClasses().print( os );
@@ -51 +50 @@
         if ( base ) {
                 os << " for ";
-                base->print( os, indent );
+                base->print( os, indent+1 );
         } // if
         if ( ! parameters.empty() ) {
-                os << endl << string( indent, ' ' ) << "with parameters" << endl;
-                printAll( parameters, os, indent+2 );
+                os << endl << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
         } // if
         if ( ! assertions.empty() ) {
-                os << endl << string( indent, ' ' ) << "with assertions" << endl;
-                printAll( assertions, os, indent+2 );
+                os << endl << indent << "... with assertions" << endl;
+                printAll( assertions, os, indent+1 );
         } // if
 }
 
-void NamedTypeDecl::printShort( std::ostream &os, int indent ) const {
+void NamedTypeDecl::printShort( std::ostream &os, Indenter indent ) const {
         using namespace std;
 
-        if ( get_name() != "" ) {
-                os << get_name() << ": ";
-        } // if
+        if ( name != "" ) os << name << ": ";
         get_storageClasses().print( os );
         os << typeString();
         if ( base ) {
                 os << " for ";
-                base->print( os, indent );
+                base->print( os, indent+1 );
         } // if
         if ( ! parameters.empty() ) {
-                os << endl << string( indent, ' ' ) << "with parameters" << endl;
-                printAll( parameters, os, indent+2 );
+                os << endl << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
         } // if
 }

src/SynTree/ObjectDecl.cc

@@ -44 +44 @@
 }
 
-void ObjectDecl::print( std::ostream &os, int indent ) const {
-        if ( get_name() != "" ) {
-                os << get_name() << ": ";
+void ObjectDecl::print( std::ostream &os, Indenter indent ) const {
+        if ( name != "" ) os << name << ": ";
+
+        if ( linkage != LinkageSpec::Cforall ) {
+                os << LinkageSpec::linkageName( linkage ) << " ";
         } // if
-
-        if ( get_linkage() != LinkageSpec::Cforall ) {
-                os << LinkageSpec::linkageName( get_linkage() ) << " ";
-        } // if
-
-        printAll( get_attributes(), os, indent );
 
         get_storageClasses().print( os );
 
-        if ( get_type() ) {
-                get_type()->print( os, indent );
+        if ( type ) {
+                type->print( os, indent );
         } else {
                 os << " untyped entity ";
@@ -64 +60 @@
 
         if ( init ) {
-                os << " with initializer " << std::endl;
-                init->print( os, indent+2 );
-                os << std::endl << std::string(indent+2, ' ');
-                os << "maybeConstructed? " << init->get_maybeConstructed();
+                os << " with initializer (" << (init->get_maybeConstructed() ? "maybe constructed" : "not constructed") << ")" << std::endl << indent+1;
+                init->print( os, indent+1 );
+                os << std::endl;
         } // if
 
+        if ( ! attributes.empty() ) {
+                os << std::endl << indent << "... with attributes: " << std::endl;
+                printAll( attributes, os, indent+1 );
+        }
+
         if ( bitfieldWidth ) {
-                os << std::string(indent, ' ');
-                os << " with bitfield width ";
+                os << indent << " with bitfield width ";
                 bitfieldWidth->print( os );
         } // if
 }
 
-void ObjectDecl::printShort( std::ostream &os, int indent ) const {
+void ObjectDecl::printShort( std::ostream &os, Indenter indent ) const {
 #if 0
         if ( get_mangleName() != "") {
@@ -83 +82 @@
         } else
 #endif
-        if ( get_name() != "" ) {
-                os << get_name() << ": ";
-        } // if
-
-        // xxx - should printShort print attributes?
+        if ( name != "" ) os << name << ": ";
 
         get_storageClasses().print( os );
 
-        if ( get_type() ) {
-                get_type()->print( os, indent );
+        if ( type ) {
+                type->print( os, indent );
         } else {
                 os << "untyped entity ";

src/SynTree/PointerType.cc

@@ -41 +41 @@
 }
 
-void PointerType::print( std::ostream &os, int indent ) const {
+void PointerType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
         if ( ! is_array() ) {

src/SynTree/ReferenceToType.cc

@@ -14 +14 @@
 //
 
-#include <stddef.h>          // for NULL
 #include <cassert>           // for assert
 #include <list>              // for list, _List_const_iterator, list<>::cons...
@@ -38 +37 @@
 }
 
-void ReferenceToType::print( std::ostream &os, int indent ) const {
+void ReferenceToType::print( std::ostream &os, Indenter indent ) const {
         using std::endl;
 
@@ -44 +43 @@
         os << "instance of " << typeString() << " " << name << " ";
         if ( ! parameters.empty() ) {
-                os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
-                printAll( parameters, os, indent+2 );
+                os << endl << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
         } // if
 }
@@ -65 +64 @@
 
 std::list<TypeDecl*>* StructInstType::get_baseParameters() {
-        if ( ! baseStruct ) return NULL;
+        if ( ! baseStruct ) return nullptr;
         return &baseStruct->get_parameters();
 }
@@ -76 +75 @@
 }
 
-void StructInstType::print( std::ostream &os, int indent ) const {
+void StructInstType::print( std::ostream &os, Indenter indent ) const {
         using std::endl;
 
-        if ( baseStruct == NULL ) ReferenceToType::print( os, indent );
+        if ( baseStruct == nullptr ) ReferenceToType::print( os, indent );
         else {
                 Type::print( os, indent );
                 os << "instance of " << typeString() << " " << name << " with body " << baseStruct->has_body() << " ";
                 if ( ! parameters.empty() ) {
-                        os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
-                        printAll( parameters, os, indent+2 );
+                        os << endl << indent << "... with parameters" << endl;
+                        printAll( parameters, os, indent+1 );
                 } // if
         } // if
@@ -97 +96 @@
 
 std::list< TypeDecl * > * UnionInstType::get_baseParameters() {
-        if ( ! baseUnion ) return NULL;
+        if ( ! baseUnion ) return nullptr;
         return &baseUnion->get_parameters();
 }
@@ -108 +107 @@
 }
 
-void UnionInstType::print( std::ostream &os, int indent ) const {
+void UnionInstType::print( std::ostream &os, Indenter indent ) const {
         using std::endl;
 
-        if ( baseUnion == NULL ) ReferenceToType::print( os, indent );
+        if ( baseUnion == nullptr ) ReferenceToType::print( os, indent );
         else {
                 Type::print( os, indent );
                 os << "instance of " << typeString() << " " << name << " with body " << baseUnion->has_body() << " ";
                 if ( ! parameters.empty() ) {
-                        os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
-                        printAll( parameters, os, indent+2 );
+                        os << endl << indent << "... with parameters" << endl;
+                        printAll( parameters, os, indent+1 );
                 } // if
         } // if
@@ -129 +128 @@
 
 bool EnumInstType::isComplete() const { return baseEnum ? baseEnum->has_body() : false; }
+
+void EnumInstType::print( std::ostream &os, Indenter indent ) const {
+        using std::endl;
+
+        if ( baseEnum == nullptr ) ReferenceToType::print( os, indent );
+        else {
+                Type::print( os, indent );
+                os << "instance of " << typeString() << " " << name << " with body " << baseEnum->has_body() << " ";
+        } // if
+}
+
 
 std::string TraitInstType::typeString() const { return "trait"; }
@@ -166 +176 @@
 bool TypeInstType::isComplete() const { return baseType->isComplete(); }
 
-void TypeInstType::print( std::ostream &os, int indent ) const {
+void TypeInstType::print( std::ostream &os, Indenter indent ) const {
         using std::endl;
 
@@ -172 +182 @@
         os << "instance of " << typeString() << " " << get_name() << " (" << ( isFtype ? "" : "not" ) << " function type) ";
         if ( ! parameters.empty() ) {
-                os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
-                printAll( parameters, os, indent+2 );
+                os << endl << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
         } // if
 }

src/SynTree/ReferenceType.cc

@@ -35 +35 @@
 }
 
-void ReferenceType::print( std::ostream &os, int indent ) const {
+void ReferenceType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
         os << "reference to ";

src/SynTree/Statement.cc

@@ -34 +34 @@
 Statement::Statement( std::list<Label> labels ) : labels( labels ) {}
 
-void Statement::print( __attribute__((unused)) std::ostream &, __attribute__((unused)) int indent ) const {}
+void Statement::print( std::ostream & os, Indenter ) const {
+        if ( ! labels.empty() ) {
+                os << "Labels: {";
+                for ( const Label & l : labels ) {
+                        os << l << ",";
+                }
+                os << "}" << endl;
+        }
+}
 
 Statement::~Statement() {}
@@ -46 +54 @@
 }
 
-void ExprStmt::print( std::ostream &os, int indent ) const {
-        os << "Expression Statement:" << endl << std::string( indent + 2, ' ' );
-        expr->print( os, indent + 2 );
+void ExprStmt::print( std::ostream &os, Indenter indent ) const {
+        os << "Expression Statement:" << endl << indent+1;
+        expr->print( os, indent+1 );
 }
 
@@ -67 +75 @@
 }
 
-void AsmStmt::print( std::ostream &os, int indent ) const {
+void AsmStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Assembler Statement:" << endl;
-        os << std::string( indent, ' ' ) << "instruction: " << endl << std::string( indent, ' ' );
-        instruction->print( os, indent + 2 );
+        os << indent+1 << "instruction: " << endl << indent;
+        instruction->print( os, indent+1 );
         if ( ! output.empty() ) {
-                os << endl << std::string( indent, ' ' ) << "output: " << endl;
-                printAll( output, os, indent + 2 );
+                os << endl << indent+1 << "output: " << endl;
+                printAll( output, os, indent+1 );
         } // if
         if ( ! input.empty() ) {
-                os << std::string( indent, ' ' ) << "input: " << endl << std::string( indent, ' ' );
-                printAll( input, os, indent + 2 );
+                os << indent+1 << "input: " << endl;
+                printAll( input, os, indent+1 );
         } // if
         if ( ! clobber.empty() ) {
-                os << std::string( indent, ' ' ) << "clobber: " << endl;
-                printAll( clobber, os, indent + 2 );
+                os << indent+1 << "clobber: " << endl;
+                printAll( clobber, os, indent+1 );
         } // if
 }
@@ -103 +111 @@
 }
 
-void BranchStmt::print( std::ostream &os, int indent ) const {
-        os << string( indent, ' ' ) << "Branch (" << brType[type] << ")" << endl ;
-        if ( target != "" ) os << string( indent+2, ' ' ) << "with target: " << target << endl;
-        if ( originalTarget != "" ) os << string( indent+2, ' ' ) << "with original target: " << originalTarget << endl;
-        if ( computedTarget != nullptr ) os << string( indent+2, ' ' ) << "with computed target: " << computedTarget << endl;
+void BranchStmt::print( std::ostream &os, Indenter indent ) const {
+        os << "Branch (" << brType[type] << ")" << endl ;
+        if ( target != "" ) os << indent+1 << "with target: " << target << endl;
+        if ( originalTarget != "" ) os << indent+1 << "with original target: " << originalTarget << endl;
+        if ( computedTarget != nullptr ) os << indent+1 << "with computed target: " << computedTarget << endl;
 }
 
@@ -118 +126 @@
 }
 
-void ReturnStmt::print( std::ostream &os, int indent ) const {
-        os <<  "Return Statement, returning: ";
-        if ( expr != 0 ) {
-                os << endl << string( indent+2, ' ' );
-                expr->print( os, indent + 2 );
+void ReturnStmt::print( std::ostream &os, Indenter indent ) const {
+        os << "Return Statement, returning: ";
+        if ( expr != nullptr ) {
+                os << endl << indent+1;
+                expr->print( os, indent+1 );
         }
         os << endl;
@@ -142 +150 @@
 }
 
-void IfStmt::print( std::ostream &os, int indent ) const {
-        os << "If on condition: " << endl ;
-        os << string( indent+4, ' ' );
-        condition->print( os, indent + 4 );
+void IfStmt::print( std::ostream &os, Indenter indent ) const {
+        os << "If on condition: " << endl;
+        os << indent+1;
+        condition->print( os, indent+1 );
 
         if ( !initialization.empty() ) {
-                os << string( indent + 2, ' ' ) << "initialization: \n";
-                for ( std::list<Statement *>::const_iterator it = initialization.begin(); it != initialization.end(); ++it ) {
-                        os << string( indent + 4, ' ' );
-                        (*it)->print( os, indent + 4 );
+                os << indent << "... with initialization: \n";
+                for ( const Statement * stmt : initialization ) {
+                        os << indent+1;
+                        stmt->print( os, indent+1 );
                 }
                 os << endl;
         }
 
-        os << string( indent+2, ' ' ) << "... then: " << endl;
-
-        os << string( indent+4, ' ' );
-        thenPart->print( os, indent + 4 );
+        os << indent << "... then: " << endl;
+
+        os << indent+1;
+        thenPart->print( os, indent+1 );
 
         if ( elsePart != 0 ) {
-                os << string( indent+2, ' ' ) << "... else: " << endl;
-                os << string( indent+4, ' ' );
-                elsePart->print( os, indent + 4 );
+                os << indent << "... else: " << endl;
+                os << indent+1;
+                elsePart->print( os, indent+1 );
         } // if
 }
@@ -183 +191 @@
 }
 
-void SwitchStmt::print( std::ostream &os, int indent ) const {
+void SwitchStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Switch on condition: ";
         condition->print( os );
         os << endl;
 
-        // statements
-        std::list<Statement *>::const_iterator i;
-        for ( i = statements.begin(); i != statements.end(); i++)
-                (*i)->print( os, indent + 4 );
-
-        //for_each( statements.begin(), statements.end(), mem_fun( bind1st(&Statement::print ), os ));
+        for ( const Statement * stmt : statements ) {
+                stmt->print( os, indent+1 );
+        }
 }
 
 CaseStmt::CaseStmt( std::list<Label> labels, Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
         Statement( labels ), condition( condition ), stmts( statements ), _isDefault( deflt ) {
-        if ( isDefault() && condition != 0 )
-                throw SemanticError("default with conditions");
+        if ( isDefault() && condition != 0 ) throw SemanticError("default case with condition: ", condition);
 }
 
@@ -216 +220 @@
 }
 
-void CaseStmt::print( std::ostream &os, int indent ) const {
-        os << string( indent, ' ' );
-
-        if ( isDefault() )
-                os << "Default ";
+void CaseStmt::print( std::ostream &os, Indenter indent ) const {
+        if ( isDefault() ) os << "Default ";
         else {
                 os << "Case ";
-                condition->print( os );
-        } // if
-
-        os << endl;
-
-        std::list<Statement *>::const_iterator i;
-        for ( i = stmts.begin(); i != stmts.end(); i++)
-                (*i )->print( os, indent + 4 );
+                condition->print( os, indent );
+        } // if
+        os << endl;
+
+        for ( Statement * stmt : stmts ) {
+                stmt->print( os, indent+1 );
+        }
 }
 
@@ -246 +246 @@
 }
 
-void WhileStmt::print( std::ostream &os, int indent ) const {
+void WhileStmt::print( std::ostream &os, Indenter indent ) const {
         os << "While on condition: " << endl ;
-        condition->print( os, indent + 4 );
-
-        os << string( indent, ' ' ) << ".... with body: " << endl;
-
-        if ( body != 0 ) body->print( os, indent + 4 );
+        condition->print( os, indent+1 );
+
+        os << indent << "... with body: " << endl;
+
+        if ( body != 0 ) body->print( os, indent+1 );
 }
 
@@ -272 +272 @@
 }
 
-void ForStmt::print( std::ostream &os, int indent ) const {
-        os << "Labels: {";
-        for ( std::list<Label>::const_iterator it = get_labels().begin(); it != get_labels().end(); ++it) {
-                os << *it << ",";
-        }
-        os << "}" << endl;
-
-        os << string( indent, ' ' ) << "For Statement" << endl ;
-
-        os << string( indent + 2, ' ' ) << "initialization: \n";
-        for ( std::list<Statement *>::const_iterator it = initialization.begin(); it != initialization.end(); ++it ) {
-                os << string( indent + 4, ' ' );
-                (*it)->print( os, indent + 4 );
-        }
-
-        os << "\n" << string( indent + 2, ' ' ) << "condition: \n";
-        if ( condition != 0 ) {
-                os << string( indent + 4, ' ' );
-                condition->print( os, indent + 4 );
-        }
-
-        os << "\n" << string( indent + 2, ' ' ) << "increment: \n";
-        if ( increment != 0 ) {
-                os << string( indent + 4, ' ' );
-                increment->print( os, indent + 4 );
-        }
-
-        os << "\n" << string( indent + 2, ' ' ) << "statement block: \n";
+void ForStmt::print( std::ostream &os, Indenter indent ) const {
+        Statement::print( os, indent ); // print labels
+
+        os << "For Statement" << endl;
+
+        if ( ! initialization.empty() ) {
+                os << indent << "... initialization: \n";
+                for ( Statement * stmt : initialization ) {
+                        os << indent+1;
+                        stmt->print( os, indent+1 );
+                }
+        }
+
+        if ( condition != nullptr ) {
+                os << indent << "... condition: \n" << indent+1;
+                condition->print( os, indent+1 );
+        }
+
+        if ( increment != nullptr ) {
+                os << "\n" << indent << "... increment: \n" << indent+1;
+                increment->print( os, indent+1 );
+        }
+
         if ( body != 0 ) {
-                os << string( indent + 4, ' ' );
-                body->print( os, indent + 4 );
-        }
-
+                os << "\n" << indent << "... with body: \n" << indent+1;
+                body->print( os, indent+1 );
+        }
         os << endl;
 }
@@ -322 +316 @@
 }
 
-void ThrowStmt::print( std::ostream &os, int indent) const {
+void ThrowStmt::print( std::ostream &os, Indenter indent) const {
+        if ( target ) os << "Non-Local ";
+        os << "Throw Statement, raising: ";
+        expr->print(os, indent+1);
         if ( target ) {
-                os << "Non-Local ";
-        }
-        os << "Throw Statement, raising: ";
-        expr->print(os, indent + 4);
-        if ( target ) {
-                os << "At: ";
-                target->print(os, indent + 4);
+                os << "... at: ";
+                target->print(os, indent+1);
         }
 }
@@ -348 +340 @@
 }
 
-void TryStmt::print( std::ostream &os, int indent ) const {
+void TryStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Try Statement" << endl;
-        os << string( indent + 2, ' ' ) << "with block:" << endl;
-        os << string( indent + 4, ' ' );
-        block->print( os, indent + 4 );
+        os << indent << "... with block:" << endl << indent+1;
+        block->print( os, indent+1 );
 
         // handlers
-        os << string( indent + 2, ' ' ) << "and handlers:" << endl;
-        for ( std::list<CatchStmt *>::const_iterator i = handlers.begin(); i != handlers.end(); i++) {
-                os << string( indent + 4, ' ' );
-                (*i )->print( os, indent + 4 );
+        os << indent << "... and handlers:" << endl;
+        for ( const CatchStmt * stmt : handlers ) {
+                os << indent+1;
+                stmt->print( os, indent+1 );
         }
 
         // finally block
         if ( finallyBlock != 0 ) {
-                os << string( indent + 2, ' ' ) << "and finally:" << endl;
-                finallyBlock->print( os, indent + 4 );
+                os << indent << "... and finally:" << endl << indent+1;
+                finallyBlock->print( os, indent+1 );
         } // if
 }
@@ -370 +361 @@
 CatchStmt::CatchStmt( std::list<Label> labels, Kind kind, Declaration *decl, Expression *cond, Statement *body ) :
         Statement( labels ), kind ( kind ), decl ( decl ), cond ( cond ), body( body ) {
+                assertf( decl, "Catch clause must have a declaration." );
 }
 
@@ -381 +373 @@
 }
 
-void CatchStmt::print( std::ostream &os, int indent ) const {
+void CatchStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Catch " << ((Terminate == kind) ? "Terminate" : "Resume") << " Statement" << endl;
 
-        os << string( indent + 2, ' ' ) << "... catching: ";
-        if ( decl ) {
-                decl->printShort( os, indent + 4 );
-                os << endl;
-        }
-        else
-                os << string( indent + 4 , ' ' ) << ">>> Error:  this catch clause must have a declaration <<<" << endl;
+        os << indent << "... catching: ";
+        decl->printShort( os, indent+1 );
+        os << endl;
 
         if ( cond ) {
-                os << string( indent + 2, ' ' ) << "with conditional:" << endl;
-                os << string( indent + 4, ' ' );
-                cond->print( os, indent + 4 );
-        }
-        else
-                os << string( indent + 2, ' ' ) << "with no conditional" << endl;
-
-        os << string( indent + 2, ' ' ) << "with block:" << endl;
-        os << string( indent + 4, ' ' );
-        body->print( os, indent + 4 );
+                os << indent << "... with conditional:" << endl << indent+1;
+                cond->print( os, indent+1 );
+        }
+
+        os << indent << "... with block:" << endl;
+        os << indent+1;
+        body->print( os, indent+1 );
 }
 
@@ -417 +402 @@
 }
 
-void FinallyStmt::print( std::ostream &os, int indent ) const {
+void FinallyStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Finally Statement" << endl;
-        os << string( indent + 2, ' ' ) << "with block:" << endl;
-        os << string( indent + 4, ' ' );
-        block->print( os, indent + 4 );
+        os << indent << "... with block:" << endl << indent+1;
+        block->print( os, indent+1 );
 }
 
@@ -465 +449 @@
 }
 
-void WaitForStmt::print( std::ostream &os, int indent ) const {
+void WaitForStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Waitfor Statement" << endl;
-        os << string( indent + 2, ' ' ) << "with block:" << endl;
-        os << string( indent + 4, ' ' );
+        os << indent << "... with block:" << endl << indent+1;
         // block->print( os, indent + 4 );
 }
@@ -475 +458 @@
 NullStmt::NullStmt() : Statement( std::list<Label>() ) {}
 
-void NullStmt::print( std::ostream &os, __attribute__((unused)) int indent ) const {
-        os << "Null Statement" << endl ;
+void NullStmt::print( std::ostream &os, Indenter ) const {
+        os << "Null Statement" << endl;
 }
 
@@ -490 +473 @@
 }
 
-void ImplicitCtorDtorStmt::print( std::ostream &os, int indent ) const {
+void ImplicitCtorDtorStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Implicit Ctor Dtor Statement" << endl;
-        os << string( indent + 2, ' ' ) << "with Ctor/Dtor: ";
-        callStmt->print( os, indent + 2);
+        os << indent << "... with Ctor/Dtor: ";
+        callStmt->print( os, indent+1);
         os << endl;
 }

src/SynTree/Statement.h

@@ -43 +43 @@
         const std::list<Label> & get_labels() const { return labels; }
 
-        virtual Statement *clone() const = 0;
+        virtual Statement *clone() const override = 0;
         virtual void accept( Visitor &v ) override = 0;
-        virtual Statement *acceptMutator( Mutator &m ) = 0;
-        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual Statement *acceptMutator( Mutator &m ) override = 0;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 
@@ -65 +65 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 
@@ -76 +76 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 
@@ -93 +93 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 
@@ -124 +124 @@
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Statement * acceptMutator( Mutator & m ) { return m.mutate( this ); }
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -150 +150 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 
@@ -171 +171 @@
 
         virtual SwitchStmt *clone() const override { return new SwitchStmt( *this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 
 };
@@ -199 +199 @@
 
         virtual CaseStmt *clone() const override { return new CaseStmt( *this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
   private:
         bool _isDefault;
@@ -225 +225 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 
@@ -251 +251 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 
@@ -280 +280 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
   private:
         static const char *brType[];
@@ -299 +299 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 
@@ -323 +323 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 
@@ -346 +346 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 
@@ -374 +374 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 
@@ -391 +391 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 
@@ -428 +428 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 
 };
@@ -448 +448 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 
@@ -470 +470 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 

src/SynTree/TupleExpr.cc

@@ -28 +28 @@
 #include "Type.h"               // for TupleType, Type
 
-UntypedTupleExpr::UntypedTupleExpr( const std::list< Expression * > & exprs, Expression *_aname ) : Expression( _aname ), exprs( exprs ) {
+UntypedTupleExpr::UntypedTupleExpr( const std::list< Expression * > & exprs ) : Expression(), exprs( exprs ) {
 }
 
@@ -39 +39 @@
 }
 
-void UntypedTupleExpr::print( std::ostream &os, int indent ) const {
+void UntypedTupleExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Untyped Tuple:" << std::endl;
-        printAll( exprs, os, indent+2 );
+        printAll( exprs, os, indent+1 );
         Expression::print( os, indent );
 }
 
-TupleExpr::TupleExpr( const std::list< Expression * > & exprs, Expression *_aname ) : Expression( _aname ), exprs( exprs ) {
+TupleExpr::TupleExpr( const std::list< Expression * > & exprs ) : Expression(), exprs( exprs ) {
         set_result( Tuples::makeTupleType( exprs ) );
 }
@@ -57 +57 @@
 }
 
-void TupleExpr::print( std::ostream &os, int indent ) const {
+void TupleExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Tuple:" << std::endl;
-        printAll( exprs, os, indent+2 );
+        printAll( exprs, os, indent+1 );
         Expression::print( os, indent );
 }
@@ -78 +78 @@
 }
 
-void TupleIndexExpr::print( std::ostream &os, int indent ) const {
+void TupleIndexExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Tuple Index Expression, with tuple:" << std::endl;
-        os << std::string( indent+2, ' ' );
-        tuple->print( os, indent+2 );
-        os << std::string( indent+2, ' ' ) << "with index: " << index << std::endl;
+        os << indent+1;
+        tuple->print( os, indent+1 );
+        os << indent+1 << "with index: " << index << std::endl;
         Expression::print( os, indent );
 }
 
-TupleAssignExpr::TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname ) : Expression( _aname ) {
+TupleAssignExpr::TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls ) : Expression() {
         // convert internally into a StmtExpr which contains the declarations and produces the tuple of the assignments
         set_result( Tuples::makeTupleType( assigns ) );
@@ -109 +109 @@
 }
 
-void TupleAssignExpr::print( std::ostream &os, int indent ) const {
+void TupleAssignExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Tuple Assignment Expression, with stmt expr:" << std::endl;
-        os << std::string( indent+2, ' ' );
-        stmtExpr->print( os, indent+4 );
+        os << indent+1;
+        stmtExpr->print( os, indent+1 );
         Expression::print( os, indent );
 }

src/SynTree/TupleType.cc

@@ -48 +48 @@
 }
 
-void TupleType::print( std::ostream &os, int indent ) const {
+void TupleType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
         os << "tuple of types" << std::endl;
-        printAll( types, os, indent+2 );
+        printAll( types, os, indent+1 );
 }
 

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 11 13:21:25 2017
-// Update Count     : 37
+// Last Modified On : Mon Sep 25 15:16:32 2017
+// Update Count     : 38
 //
 #include "Type.h"
@@ -45 +45 @@
         "double _Imaginary",
         "long double _Imaginary",
+        "__int128",
+        "unsigned __int128",
 };
 
@@ -73 +75 @@
         Type * type;
         ReferenceType * ref;
-        for ( type = this; (ref = dynamic_cast<ReferenceType *>( type )); type = ref->get_base() );
+        for ( type = this; (ref = dynamic_cast<ReferenceType *>( type )); type = ref->base );
         return type;
 }
@@ -79 +81 @@
 int Type::referenceDepth() const { return 0; }
 
-void Type::print( std::ostream &os, int indent ) const {
+void Type::print( std::ostream &os, Indenter indent ) const {
         if ( ! forall.empty() ) {
                 os << "forall" << std::endl;
-                printAll( forall, os, indent + 4 );
-                os << std::string( indent+2, ' ' );
+                printAll( forall, os, indent+1 );
+                os << ++indent;
         } // if
 
         if ( ! attributes.empty() ) {
-                os << endl << string( indent+2, ' ' ) << "with attributes" << endl;
-                printAll( attributes, os, indent+4 );
+                os << "with attributes" << endl;
+                printAll( attributes, os, indent+1 );
         } // if
 

src/SynTree/Type.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Wed Aug  9 14:25:00 2017
-// Update Count     : 152
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Sep 25 14:14:01 2017
+// Update Count     : 154
 //
 
@@ -181 +181 @@
         virtual void accept( Visitor & v ) = 0;
         virtual Type *acceptMutator( Mutator & m ) = 0;
-        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -198 +198 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -225 +225 @@
                 DoubleImaginary,
                 LongDoubleImaginary,
+                SignedInt128,
+                UnsignedInt128,
                 NUMBER_OF_BASIC_TYPES
         } kind;
@@ -238 +240 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 
         bool isInteger() const;
@@ -273 +275 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -301 +303 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -325 +327 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -352 +354 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -374 +376 @@
         virtual void accept( Visitor & v ) override = 0;
         virtual Type *acceptMutator( Mutator & m ) override = 0;
-        virtual void print( std::ostream & os, int indent = 0 ) const override;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 
         virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
@@ -408 +410 @@
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
 
-        virtual void print( std::ostream & os, int indent = 0 ) const override;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
   private:
         virtual std::string typeString() const override;
@@ -440 +442 @@
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
 
-        virtual void print( std::ostream & os, int indent = 0 ) const override;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
   private:
         virtual std::string typeString() const override;
@@ -464 +466 @@
         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;
   private:
         virtual std::string typeString() const override;
@@ -512 +516 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
   private:
         virtual std::string typeString() const override;
@@ -549 +553 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -568 +572 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -597 +601 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -611 +615 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -623 +627 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -635 +639 @@
         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, int indent = 0 ) const override;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 

src/SynTree/TypeDecl.cc

@@ -41 +41 @@
 }
 
-void TypeDecl::print( std::ostream &os, int indent ) const {
+void TypeDecl::print( std::ostream &os, Indenter indent ) const {
   NamedTypeDecl::print( os, indent );
   if ( init ) {
-    os << std::endl << std::string( indent, ' ' ) << "with type initializer: ";
-    init->print( os, indent + 2 );
+    os << std::endl << indent << "with type initializer: ";
+    init->print( os, indent + 1 );
   }
 }

src/SynTree/TypeExpr.cc

@@ -30 +30 @@
 }
 
-void TypeExpr::print( std::ostream &os, int indent ) const {
+void TypeExpr::print( std::ostream &os, Indenter indent ) const {
         if ( type ) type->print( os, indent );
         Expression::print( os, indent );

src/SynTree/TypeSubstitution.cc

@@ -148 +148 @@
 template< typename TypeClass >
 Type *TypeSubstitution::handleType( TypeClass *type ) {
-        BoundVarsType oldBoundVars( boundVars );
+        ValueGuard<BoundVarsType> oldBoundVars( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
@@ -156 +156 @@
         } // if
         Type *ret = Mutator::mutate( type );
-        boundVars = oldBoundVars;
         return ret;
 }
@@ -162 +161 @@
 template< typename TypeClass >
 Type *TypeSubstitution::handleAggregateType( TypeClass *type ) {
-        BoundVarsType oldBoundVars( boundVars );
+        ValueGuard<BoundVarsType> oldBoundVars( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
@@ -177 +176 @@
         } // if
         Type *ret = Mutator::mutate( type );
-        boundVars = oldBoundVars;
         return ret;
 }
@@ -233 +231 @@
 }
 
-TypeSubstitution * TypeSubstitution::acceptMutator( Mutator & mutator ) {
-        for ( auto & p : typeEnv ) {
-                p.second = maybeMutate( p.second, mutator );
-        }
-        for ( auto & p : varEnv ) {
-                p.second = maybeMutate( p.second, mutator );
-        }
-        return this;
-}
-
-void TypeSubstitution::print( std::ostream &os, int indent ) const {
-        os << std::string( indent, ' ' ) << "Types:" << std::endl;
+void TypeSubstitution::print( std::ostream &os, Indenter indent ) const {
+        os << indent << "Types:" << std::endl;
         for ( TypeEnvType::const_iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
-                os << std::string( indent+2, ' ' ) << i->first << " -> ";
-                i->second->print( os, indent+4 );
+                os << indent+1 << i->first << " -> ";
+                i->second->print( os, indent+2 );
                 os << std::endl;
         } // for
-        os << std::string( indent, ' ' ) << "Non-types:" << std::endl;
+        os << indent << "Non-types:" << std::endl;
         for ( VarEnvType::const_iterator i = varEnv.begin(); i != varEnv.end(); ++i ) {
-                os << std::string( indent+2, ' ' ) << i->first << " -> ";
-                i->second->print( os, indent+4 );
+                os << indent+1 << i->first << " -> ";
+                i->second->print( os, indent+2 );
                 os << std::endl;
         } // for

src/SynTree/TypeSubstitution.h

@@ -59 +59 @@
         void normalize();
 
-        TypeSubstitution * acceptMutator( Mutator & mutator );
+        TypeSubstitution * acceptMutator( Mutator & m ) { return m.mutate( this ); }
 
-        void print( std::ostream &os, int indent = 0 ) const;
+        void print( std::ostream &os, Indenter indent = {} ) const;
         TypeSubstitution *clone() const { return new TypeSubstitution( *this ); }
   private:
@@ -89 +89 @@
 
         void initialize( const TypeSubstitution &src, TypeSubstitution &dest );
+
+        friend class Mutator;
+
+        template<typename pass_type>
+        friend class PassVisitor;
 
         typedef std::map< std::string, Type* > TypeEnvType;

src/SynTree/TypeofType.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// TypeofType.cc -- 
+// TypeofType.cc --
 //
 // Author           : Richard C. Bilson
@@ -33 +33 @@
 }
 
-void TypeofType::print( std::ostream &os, int indent ) const {
+void TypeofType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
         os << "type-of expression ";

src/SynTree/VarArgsType.cc

@@ -25 +25 @@
 VarArgsType::VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
 
-void VarArgsType::print( std::ostream &os, int indent ) const {
+void VarArgsType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
         os << "builtin var args pack";

src/SynTree/VoidType.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// VoidType.cc -- 
+// VoidType.cc --
 //
 // Author           : Richard C. Bilson
@@ -24 +24 @@
 }
 
-void VoidType::print( std::ostream &os, int indent ) const {
+void VoidType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
         os << "void ";

src/SynTree/ZeroOneType.cc

@@ -25 +25 @@
 ZeroType::ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
 
-void ZeroType::print( std::ostream &os, __attribute__((unused)) int indent ) const {
+void ZeroType::print( std::ostream &os, Indenter ) const {
         os << "zero_t";
 }
@@ -33 +33 @@
 OneType::OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
 
-void OneType::print( std::ostream &os, __attribute__((unused)) int indent ) const {
+void OneType::print( std::ostream &os, Indenter ) const {
         os << "one_t";
 }