Index: src/SynTree/Expression.h
===================================================================
--- src/SynTree/Expression.h	(revision 44a8185351c38769b27c73139cd5861fa62279f3)
+++ src/SynTree/Expression.h	(revision 5ded7395234578d7bb8fba071aabd2c9c3142fa2)
@@ -10,6 +10,6 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Aug  6 08:52:53 2016
-// Update Count     : 35
+// Last Modified On : Sat Jan 14 14:37:54 2017
+// Update Count     : 37
 //
 
@@ -28,27 +28,27 @@
 class Expression {
   public:
-	Expression( Expression *_aname = nullptr );
-	Expression( const Expression &other );
+	Expression( Expression * _aname = nullptr );
+	Expression( const Expression & other );
 	virtual ~Expression();
 
 	Type *& get_result() { return result; }
-	void set_result( Type *newValue ) { result = newValue; }
+	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; }
+	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 = 0;
+	virtual void accept( Visitor & v ) = 0;
+	virtual Expression * acceptMutator( Mutator & m ) = 0;
+	virtual void print( std::ostream & os, int indent = 0 ) const;
   protected:
 	Type * result;
-	TypeSubstitution *env;
-	Expression* argName; // if expression is used as an argument, it can be "designated" by this name
+	TypeSubstitution * env;
+	Expression * argName; // if expression is used as an argument, it can be "designated" by this name
 	bool extension = false;
 };
@@ -61,12 +61,12 @@
 struct ParamEntry {
 	ParamEntry(): decl( 0 ), actualType( 0 ), formalType( 0 ), expr( 0 ), inferParams( new InferredParams ) {}
-	ParamEntry( UniqueId decl, Type *actualType, Type *formalType, Expression* expr ): decl( decl ), actualType( actualType ), formalType( formalType ), expr( expr ), inferParams( new InferredParams ) {}
-	ParamEntry( const ParamEntry &other );
+	ParamEntry( UniqueId decl, Type * actualType, Type * formalType, Expression* expr ): decl( decl ), actualType( actualType ), formalType( formalType ), expr( expr ), inferParams( new InferredParams ) {}
+	ParamEntry( const ParamEntry & other );
 	~ParamEntry();
-	ParamEntry &operator=( const ParamEntry &other );
+	ParamEntry & operator=( const ParamEntry & other );
 
 	UniqueId decl;
-	Type *actualType;
-	Type *formalType;
+	Type * actualType;
+	Type * formalType;
 	Expression* expr;
 	std::unique_ptr< InferredParams > inferParams;
@@ -77,19 +77,19 @@
 class ApplicationExpr : public Expression {
   public:
-	ApplicationExpr( Expression *function );
-	ApplicationExpr( const ApplicationExpr &other );
+	ApplicationExpr( Expression * function );
+	ApplicationExpr( const ApplicationExpr & other );
 	virtual ~ApplicationExpr();
 
-	Expression *get_function() const { return function; }
-	void set_function( Expression *newValue ) { function = newValue; }
+	Expression * get_function() const { return function; }
+	void set_function( Expression * newValue ) { function = newValue; }
 	std::list<Expression *>& get_args() { return args; }
-	InferredParams &get_inferParams() { return inferParams; }
-
-	virtual ApplicationExpr *clone() const { return new ApplicationExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-	Expression *function;
+	InferredParams & get_inferParams() { return inferParams; }
+
+	virtual ApplicationExpr * clone() const { return new ApplicationExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+	Expression * function;
 	std::list<Expression *> args;
 	InferredParams inferParams;
@@ -101,12 +101,12 @@
 class UntypedExpr : public Expression {
   public:
-	UntypedExpr( Expression *function, const std::list<Expression *> &args = std::list< Expression * >(), Expression *_aname = nullptr );
-	UntypedExpr( const UntypedExpr &other );
+	UntypedExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >(), Expression *_aname = nullptr );
+	UntypedExpr( const UntypedExpr & other );
 	virtual ~UntypedExpr();
 
-	Expression *get_function() const { return function; }
-	void set_function( Expression *newValue ) { function = newValue; }
-
-	void set_args( std::list<Expression *> &listArgs ) { args = listArgs; }
+	Expression * get_function() const { return function; }
+	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(); }
@@ -116,11 +116,11 @@
 	static UntypedExpr * createAssign( Expression * arg1, Expression * arg2 );
 
-	virtual UntypedExpr *clone() const { return new UntypedExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-	virtual void printArgs(std::ostream &os, int indent = 0) const;
-  private:
-	Expression *function;
+	virtual UntypedExpr * clone() const { return new UntypedExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
+	virtual void printArgs(std::ostream & os, int indent = 0) const;
+  private:
+	Expression * function;
 	std::list<Expression*> args;
 };
@@ -130,14 +130,14 @@
   public:
 	NameExpr( std::string name, Expression *_aname = nullptr );
-	NameExpr( const NameExpr &other );
+	NameExpr( const NameExpr & other );
 	virtual ~NameExpr();
 
-	const std::string &get_name() const { return name; }
+	const std::string & get_name() const { return name; }
 	void set_name( std::string newValue ) { name = newValue; }
 
-	virtual NameExpr *clone() const { return new NameExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual NameExpr * clone() const { return new NameExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
 	std::string name;
@@ -147,20 +147,20 @@
 // function-call format.
 
-/// AddressExpr represents a address-of expression, e.g. &e
+/// AddressExpr represents a address-of expression, e.g. & e
 class AddressExpr : public Expression {
   public:
-	AddressExpr( Expression *arg, Expression *_aname = nullptr );
-	AddressExpr( const AddressExpr &other );
+	AddressExpr( Expression * arg, Expression *_aname = nullptr );
+	AddressExpr( const AddressExpr & other );
 	virtual ~AddressExpr();
 
-	Expression *get_arg() const { return arg; }
-	void set_arg(Expression *newValue ) { arg = newValue; }
-
-	virtual AddressExpr *clone() const { return new AddressExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-	Expression *arg;
+	Expression * get_arg() const { return arg; }
+	void set_arg(Expression * newValue ) { arg = newValue; }
+
+	virtual AddressExpr * clone() const { return new AddressExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+	Expression * arg;
 };
 
@@ -168,17 +168,17 @@
 class LabelAddressExpr : public Expression {
   public:
-	LabelAddressExpr( Expression *arg );
-	LabelAddressExpr( const LabelAddressExpr &other );
+	LabelAddressExpr( Expression * arg );
+	LabelAddressExpr( const LabelAddressExpr & other );
 	virtual ~LabelAddressExpr();
 
-	Expression *get_arg() const { return arg; }
-	void set_arg(Expression *newValue ) { arg = newValue; }
-
-	virtual LabelAddressExpr *clone() const { return new LabelAddressExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-	Expression *arg;
+	Expression * get_arg() const { return arg; }
+	void set_arg(Expression * newValue ) { arg = newValue; }
+
+	virtual LabelAddressExpr * clone() const { return new LabelAddressExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+	Expression * arg;
 };
 
@@ -186,18 +186,18 @@
 class CastExpr : public Expression {
   public:
-	CastExpr( Expression *arg, Expression *_aname = nullptr );
-	CastExpr( Expression *arg, Type *toType, Expression *_aname = nullptr );
-	CastExpr( const CastExpr &other );
+	CastExpr( Expression * arg, Expression *_aname = nullptr );
+	CastExpr( Expression * arg, Type * toType, Expression *_aname = nullptr );
+	CastExpr( const CastExpr & other );
 	virtual ~CastExpr();
 
-	Expression *get_arg() const { return arg; }
-	void set_arg(Expression *newValue ) { arg = newValue; }
-
-	virtual CastExpr *clone() const { return new CastExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-	Expression *arg;
+	Expression * get_arg() const { return arg; }
+	void set_arg(Expression * newValue ) { arg = newValue; }
+
+	virtual CastExpr * clone() const { return new CastExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+	Expression * arg;
 };
 
@@ -205,20 +205,20 @@
 class UntypedMemberExpr : public Expression {
   public:
-	UntypedMemberExpr( Expression *member, Expression *aggregate, Expression *_aname = nullptr );
-	UntypedMemberExpr( const UntypedMemberExpr &other );
+	UntypedMemberExpr( Expression * member, Expression * aggregate, Expression *_aname = nullptr );
+	UntypedMemberExpr( const UntypedMemberExpr & other );
 	virtual ~UntypedMemberExpr();
 
 	Expression * get_member() const { return member; }
 	void set_member( Expression * newValue ) { member = newValue; }
-	Expression *get_aggregate() const { return aggregate; }
-	void set_aggregate( Expression *newValue ) { aggregate = newValue; }
-
-	virtual UntypedMemberExpr *clone() const { return new UntypedMemberExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-	Expression *member;
-	Expression *aggregate;
+	Expression * get_aggregate() const { return aggregate; }
+	void set_aggregate( Expression * newValue ) { aggregate = newValue; }
+
+	virtual UntypedMemberExpr * clone() const { return new UntypedMemberExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+	Expression * member;
+	Expression * aggregate;
 };
 
@@ -226,20 +226,20 @@
 class MemberExpr : public Expression {
   public:
-	MemberExpr( DeclarationWithType *member, Expression *aggregate, Expression *_aname = nullptr );
-	MemberExpr( const MemberExpr &other );
+	MemberExpr( DeclarationWithType * member, Expression * aggregate, Expression *_aname = nullptr );
+	MemberExpr( const MemberExpr & other );
 	virtual ~MemberExpr();
 
-	DeclarationWithType *get_member() const { return member; }
-	void set_member( DeclarationWithType *newValue ) { member = newValue; }
-	Expression *get_aggregate() const { return aggregate; }
-	void set_aggregate( Expression *newValue ) { aggregate = newValue; }
-
-	virtual MemberExpr *clone() const { return new MemberExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-	DeclarationWithType *member;
-	Expression *aggregate;
+	DeclarationWithType * get_member() const { return member; }
+	void set_member( DeclarationWithType * newValue ) { member = newValue; }
+	Expression * get_aggregate() const { return aggregate; }
+	void set_aggregate( Expression * newValue ) { aggregate = newValue; }
+
+	virtual MemberExpr * clone() const { return new MemberExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+	DeclarationWithType * member;
+	Expression * aggregate;
 };
 
@@ -247,17 +247,17 @@
 class VariableExpr : public Expression {
   public:
-	VariableExpr( DeclarationWithType *var, Expression *_aname = nullptr );
-	VariableExpr( const VariableExpr &other );
+	VariableExpr( DeclarationWithType * var, Expression *_aname = nullptr );
+	VariableExpr( const VariableExpr & other );
 	virtual ~VariableExpr();
 
-	DeclarationWithType *get_var() const { return var; }
-	void set_var( DeclarationWithType *newValue ) { var = newValue; }
-
-	virtual VariableExpr *clone() const { return new VariableExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-	DeclarationWithType *var;
+	DeclarationWithType * get_var() const { return var; }
+	void set_var( DeclarationWithType * newValue ) { var = newValue; }
+
+	virtual VariableExpr * clone() const { return new VariableExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+	DeclarationWithType * var;
 };
 
@@ -266,14 +266,14 @@
   public:
 	ConstantExpr( Constant constant, Expression *_aname = nullptr );
-	ConstantExpr( const ConstantExpr &other );
+	ConstantExpr( const ConstantExpr & other );
 	virtual ~ConstantExpr();
 
-	Constant *get_constant() { return &constant; }
-	void set_constant( const Constant &newValue ) { constant = newValue; }
-
-	virtual ConstantExpr *clone() const { return new ConstantExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	Constant * get_constant() { return & constant; }
+	void set_constant( const Constant & newValue ) { constant = newValue; }
+
+	virtual ConstantExpr * clone() const { return new ConstantExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
 	Constant constant;
@@ -283,23 +283,23 @@
 class SizeofExpr : public Expression {
   public:
-	SizeofExpr( Expression *expr, Expression *_aname = nullptr );
-	SizeofExpr( const SizeofExpr &other );
-	SizeofExpr( Type *type, Expression *_aname = nullptr );
+	SizeofExpr( Expression * expr, Expression *_aname = nullptr );
+	SizeofExpr( const SizeofExpr & other );
+	SizeofExpr( Type * type, Expression *_aname = nullptr );
 	virtual ~SizeofExpr();
 
-	Expression *get_expr() const { return expr; }
-	void set_expr( Expression *newValue ) { expr = newValue; }
-	Type *get_type() const { return type; }
-	void set_type( Type *newValue ) { type = newValue; }
+	Expression * get_expr() const { return expr; }
+	void set_expr( Expression * newValue ) { expr = newValue; }
+	Type * get_type() const { return type; }
+	void set_type( Type * newValue ) { type = newValue; }
 	bool get_isType() const { return isType; }
 	void set_isType( bool newValue ) { isType = newValue; }
 
-	virtual SizeofExpr *clone() const { return new SizeofExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-	Expression *expr;
-	Type *type;
+	virtual SizeofExpr * clone() const { return new SizeofExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+	Expression * expr;
+	Type * type;
 	bool isType;
 };
@@ -308,23 +308,23 @@
 class AlignofExpr : public Expression {
   public:
-	AlignofExpr( Expression *expr, Expression *_aname = nullptr );
-	AlignofExpr( const AlignofExpr &other );
-	AlignofExpr( Type *type, Expression *_aname = nullptr );
+	AlignofExpr( Expression * expr, Expression *_aname = nullptr );
+	AlignofExpr( const AlignofExpr & other );
+	AlignofExpr( Type * type, Expression *_aname = nullptr );
 	virtual ~AlignofExpr();
 
-	Expression *get_expr() const { return expr; }
-	void set_expr( Expression *newValue ) { expr = newValue; }
-	Type *get_type() const { return type; }
-	void set_type( Type *newValue ) { type = newValue; }
+	Expression * get_expr() const { return expr; }
+	void set_expr( Expression * newValue ) { expr = newValue; }
+	Type * get_type() const { return type; }
+	void set_type( Type * newValue ) { type = newValue; }
 	bool get_isType() const { return isType; }
 	void set_isType( bool newValue ) { isType = newValue; }
 
-	virtual AlignofExpr *clone() const { return new AlignofExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-	Expression *expr;
-	Type *type;
+	virtual AlignofExpr * clone() const { return new AlignofExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+	Expression * expr;
+	Type * type;
 	bool isType;
 };
@@ -333,19 +333,19 @@
 class UntypedOffsetofExpr : public Expression {
   public:
-	UntypedOffsetofExpr( Type *type, const std::string &member, Expression *_aname = nullptr );
-	UntypedOffsetofExpr( const UntypedOffsetofExpr &other );
+	UntypedOffsetofExpr( Type * type, const std::string & member, Expression *_aname = nullptr );
+	UntypedOffsetofExpr( const UntypedOffsetofExpr & other );
 	virtual ~UntypedOffsetofExpr();
 
 	std::string get_member() const { return member; }
-	void set_member( const std::string &newValue ) { member = newValue; }
-	Type *get_type() const { return type; }
-	void set_type( Type *newValue ) { type = newValue; }
-
-	virtual UntypedOffsetofExpr *clone() const { return new UntypedOffsetofExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-	Type *type;
+	void set_member( const std::string & newValue ) { member = newValue; }
+	Type * get_type() const { return type; }
+	void set_type( Type * newValue ) { type = newValue; }
+
+	virtual UntypedOffsetofExpr * clone() const { return new UntypedOffsetofExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+	Type * type;
 	std::string member;
 };
@@ -354,20 +354,20 @@
 class OffsetofExpr : public Expression {
   public:
-	OffsetofExpr( Type *type, DeclarationWithType *member, Expression *_aname = nullptr );
-	OffsetofExpr( const OffsetofExpr &other );
+	OffsetofExpr( Type * type, DeclarationWithType * member, Expression *_aname = nullptr );
+	OffsetofExpr( const OffsetofExpr & other );
 	virtual ~OffsetofExpr();
 
-	Type *get_type() const { return type; }
-	void set_type( Type *newValue ) { type = newValue; }
-	DeclarationWithType *get_member() const { return member; }
-	void set_member( DeclarationWithType *newValue ) { member = newValue; }
-
-	virtual OffsetofExpr *clone() const { return new OffsetofExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-	Type *type;
-	DeclarationWithType *member;
+	Type * get_type() const { return type; }
+	void set_type( Type * newValue ) { type = newValue; }
+	DeclarationWithType * get_member() const { return member; }
+	void set_member( DeclarationWithType * newValue ) { member = newValue; }
+
+	virtual OffsetofExpr * clone() const { return new OffsetofExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+	Type * type;
+	DeclarationWithType * member;
 };
 
@@ -375,19 +375,19 @@
 class OffsetPackExpr : public Expression {
 public:
-	OffsetPackExpr( StructInstType *type_, Expression *aname_ = 0 );
-	OffsetPackExpr( const OffsetPackExpr &other );
+	OffsetPackExpr( StructInstType * type_, Expression * aname_ = 0 );
+	OffsetPackExpr( const OffsetPackExpr & other );
 	virtual ~OffsetPackExpr();
 
-	StructInstType *get_type() const { return type; }
-	void set_type( StructInstType *newValue ) { type = newValue; }
-
-	virtual OffsetPackExpr *clone() const { return new OffsetPackExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	StructInstType * get_type() const { return type; }
+	void set_type( StructInstType * newValue ) { type = newValue; }
+
+	virtual OffsetPackExpr * clone() const { return new OffsetPackExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+
+	virtual void print( std::ostream & os, int indent = 0 ) const;
 
 private:
-	StructInstType *type;
+	StructInstType * type;
 };
 
@@ -395,26 +395,26 @@
 class AttrExpr : public Expression {
   public:
-	AttrExpr(Expression *attr, Expression *expr, Expression *_aname = nullptr );
-	AttrExpr( const AttrExpr &other );
-	AttrExpr( Expression *attr, Type *type, Expression *_aname = nullptr );
+	AttrExpr(Expression * attr, Expression * expr, Expression *_aname = nullptr );
+	AttrExpr( const AttrExpr & other );
+	AttrExpr( Expression * attr, Type * type, Expression *_aname = nullptr );
 	virtual ~AttrExpr();
 
-	Expression *get_attr() const { return attr; }
-	void set_attr( Expression *newValue ) { attr = newValue; }
-	Expression *get_expr() const { return expr; }
-	void set_expr( Expression *newValue ) { expr = newValue; }
-	Type *get_type() const { return type; }
-	void set_type( Type *newValue ) { type = newValue; }
+	Expression * get_attr() const { return attr; }
+	void set_attr( Expression * newValue ) { attr = newValue; }
+	Expression * get_expr() const { return expr; }
+	void set_expr( Expression * newValue ) { expr = newValue; }
+	Type * get_type() const { return type; }
+	void set_type( Type * newValue ) { type = newValue; }
 	bool get_isType() const { return isType; }
 	void set_isType( bool newValue ) { isType = newValue; }
 
-	virtual AttrExpr *clone() const { return new AttrExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-	Expression *attr;
-	Expression *expr;
-	Type *type;
+	virtual AttrExpr * clone() const { return new AttrExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+	Expression * attr;
+	Expression * expr;
+	Type * type;
 	bool isType;
 };
@@ -423,21 +423,21 @@
 class LogicalExpr : public Expression {
   public:
-	LogicalExpr( Expression *arg1, Expression *arg2, bool andp = true, Expression *_aname = nullptr );
-	LogicalExpr( const LogicalExpr &other );
+	LogicalExpr( Expression * arg1, Expression * arg2, bool andp = true, Expression *_aname = nullptr );
+	LogicalExpr( const LogicalExpr & other );
 	virtual ~LogicalExpr();
 
 	bool get_isAnd() const { return isAnd; }
-	Expression *get_arg1() { return arg1; }
-	void set_arg1( Expression *newValue ) { arg1 = newValue; }
-	Expression *get_arg2() const { return arg2; }
-	void set_arg2( Expression *newValue ) { arg2 = newValue; }
-
-	virtual LogicalExpr *clone() const { return new LogicalExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-	Expression *arg1;
-	Expression *arg2;
+	Expression * get_arg1() { return arg1; }
+	void set_arg1( Expression * newValue ) { arg1 = newValue; }
+	Expression * get_arg2() const { return arg2; }
+	void set_arg2( Expression * newValue ) { arg2 = newValue; }
+
+	virtual LogicalExpr * clone() const { return new LogicalExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+	Expression * arg1;
+	Expression * arg2;
 	bool isAnd;
 };
@@ -446,23 +446,23 @@
 class ConditionalExpr : public Expression {
   public:
-	ConditionalExpr( Expression *arg1, Expression *arg2, Expression *arg3, Expression *_aname = nullptr );
-	ConditionalExpr( const ConditionalExpr &other );
+	ConditionalExpr( Expression * arg1, Expression * arg2, Expression * arg3, Expression *_aname = nullptr );
+	ConditionalExpr( const ConditionalExpr & other );
 	virtual ~ConditionalExpr();
 
-	Expression *get_arg1() const { return arg1; }
-	void set_arg1( Expression *newValue ) { arg1 = newValue; }
-	Expression *get_arg2() const { return arg2; }
-	void set_arg2( Expression *newValue ) { arg2 = newValue; }
-	Expression *get_arg3() const { return arg3; }
-	void set_arg3( Expression *newValue ) { arg3 = newValue; }
-
-	virtual ConditionalExpr *clone() const { return new ConditionalExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-	Expression *arg1;
-	Expression *arg2;
-	Expression *arg3;
+	Expression * get_arg1() const { return arg1; }
+	void set_arg1( Expression * newValue ) { arg1 = newValue; }
+	Expression * get_arg2() const { return arg2; }
+	void set_arg2( Expression * newValue ) { arg2 = newValue; }
+	Expression * get_arg3() const { return arg3; }
+	void set_arg3( Expression * newValue ) { arg3 = newValue; }
+
+	virtual ConditionalExpr * clone() const { return new ConditionalExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+	Expression * arg1;
+	Expression * arg2;
+	Expression * arg3;
 };
 
@@ -470,20 +470,20 @@
 class CommaExpr : public Expression {
   public:
-	CommaExpr( Expression *arg1, Expression *arg2, Expression *_aname = nullptr );
-	CommaExpr( const CommaExpr &other );
+	CommaExpr( Expression * arg1, Expression * arg2, Expression *_aname = nullptr );
+	CommaExpr( const CommaExpr & other );
 	virtual ~CommaExpr();
 
-	Expression *get_arg1() const { return arg1; }
-	void set_arg1( Expression *newValue ) { arg1 = newValue; }
-	Expression *get_arg2() const { return arg2; }
-	void set_arg2( Expression *newValue ) { arg2 = newValue; }
-
-	virtual CommaExpr *clone() const { return new CommaExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-	Expression *arg1;
-	Expression *arg2;
+	Expression * get_arg1() const { return arg1; }
+	void set_arg1( Expression * newValue ) { arg1 = newValue; }
+	Expression * get_arg2() const { return arg2; }
+	void set_arg2( Expression * newValue ) { arg2 = newValue; }
+
+	virtual CommaExpr * clone() const { return new CommaExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+	Expression * arg1;
+	Expression * arg2;
 };
 
@@ -491,17 +491,17 @@
 class TypeExpr : public Expression {
   public:
-	TypeExpr( Type *type );
-	TypeExpr( const TypeExpr &other );
+	TypeExpr( Type * type );
+	TypeExpr( const TypeExpr & other );
 	virtual ~TypeExpr();
 
-	Type *get_type() const { return type; }
-	void set_type( Type *newValue ) { type = newValue; }
-
-	virtual TypeExpr *clone() const { return new TypeExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-	Type *type;
+	Type * get_type() const { return type; }
+	void set_type( Type * newValue ) { type = newValue; }
+
+	virtual TypeExpr * clone() const { return new TypeExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+	Type * type;
 };
 
@@ -509,26 +509,26 @@
 class AsmExpr : public Expression {
   public:
-	AsmExpr( Expression *inout, ConstantExpr *constraint, Expression *operand ) : inout( inout ), constraint( constraint ), operand( operand ) {}
+	AsmExpr( Expression * inout, ConstantExpr * constraint, Expression * operand ) : inout( inout ), constraint( constraint ), operand( operand ) {}
 	AsmExpr( const AsmExpr & other );
 	virtual ~AsmExpr() { delete inout; delete constraint; delete operand; };
 
-	Expression *get_inout() const { return inout; }
-	void set_inout( Expression *newValue ) { inout = newValue; }
-
-	ConstantExpr *get_constraint() const { return constraint; }
-	void set_constraint( ConstantExpr *newValue ) { constraint = newValue; }
-
-	Expression *get_operand() const { return operand; }
-	void set_operand( Expression *newValue ) { operand = newValue; }
-
-	virtual AsmExpr *clone() const { return new AsmExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	Expression * get_inout() const { return inout; }
+	void set_inout( Expression * newValue ) { inout = newValue; }
+
+	ConstantExpr * get_constraint() const { return constraint; }
+	void set_constraint( ConstantExpr * newValue ) { constraint = newValue; }
+
+	Expression * get_operand() const { return operand; }
+	void set_operand( Expression * newValue ) { operand = newValue; }
+
+	virtual AsmExpr * clone() const { return new AsmExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
 	// https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints
-	Expression *inout;
-	ConstantExpr *constraint;
-	Expression *operand;
+	Expression * inout;
+	ConstantExpr * constraint;
+	Expression * operand;
 };
 
@@ -541,6 +541,6 @@
 	virtual ~ImplicitCopyCtorExpr();
 
-	ApplicationExpr *get_callExpr() const { return callExpr; }
-	void set_callExpr( ApplicationExpr *newValue ) { callExpr = newValue; }
+	ApplicationExpr * get_callExpr() const { return callExpr; }
+	void set_callExpr( ApplicationExpr * newValue ) { callExpr = newValue; }
 
 	std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
@@ -548,8 +548,8 @@
 	std::list< Expression * > & get_dtors() { return dtors; }
 
-	virtual ImplicitCopyCtorExpr *clone() const { return new ImplicitCopyCtorExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual ImplicitCopyCtorExpr * clone() const { return new ImplicitCopyCtorExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
 	ApplicationExpr * callExpr;
@@ -566,11 +566,11 @@
 	~ConstructorExpr();
 
-	Expression *get_callExpr() const { return callExpr; }
-	void set_callExpr( Expression *newValue ) { callExpr = newValue; }
-
-	virtual ConstructorExpr *clone() const { return new ConstructorExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	Expression * get_callExpr() const { return callExpr; }
+	void set_callExpr( Expression * newValue ) { callExpr = newValue; }
+
+	virtual ConstructorExpr * clone() const { return new ConstructorExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
 private:
 	Expression * callExpr;
@@ -581,5 +581,5 @@
   public:
 	CompoundLiteralExpr( Type * type, Initializer * initializer );
-	CompoundLiteralExpr( const CompoundLiteralExpr &other );
+	CompoundLiteralExpr( const CompoundLiteralExpr & other );
 	virtual ~CompoundLiteralExpr();
 
@@ -590,8 +590,8 @@
 	void set_initializer( Initializer * i ) { initializer = i; }
 
-	virtual CompoundLiteralExpr *clone() const { return new CompoundLiteralExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual CompoundLiteralExpr * clone() const { return new CompoundLiteralExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
 	Type * type;
@@ -606,13 +606,13 @@
 	virtual ~UntypedValofExpr();
 
-	Expression *get_value();
-	Statement *get_body() const { return body; }
-
-	virtual UntypedValofExpr *clone() const { return new UntypedValofExpr( *this ); }
-	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;
-  private:
-	Statement *body;
+	Expression * get_value();
+	Statement * get_body() const { return body; }
+
+	virtual UntypedValofExpr * clone() const { return new UntypedValofExpr( * this ); }
+	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;
+  private:
+	Statement * body;
 };
 
@@ -620,18 +620,18 @@
 class RangeExpr : public Expression {
   public:
-	RangeExpr( Expression *low, Expression *high );
-	RangeExpr( const RangeExpr &other );
+	RangeExpr( Expression * low, Expression * high );
+	RangeExpr( const RangeExpr & other );
 
 	Expression * get_low() const { return low; }
 	Expression * get_high() const { return high; }
-	RangeExpr * set_low( Expression *low ) { RangeExpr::low = low; return this; }
-	RangeExpr * set_high( Expression *high ) { RangeExpr::high = high; return this; }
-
-	virtual RangeExpr *clone() const { return new RangeExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-	Expression *low, *high;
+	RangeExpr * set_low( Expression * low ) { RangeExpr::low = low; return this; }
+	RangeExpr * set_high( Expression * high ) { RangeExpr::high = high; return this; }
+
+	virtual RangeExpr * clone() const { return new RangeExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
+  private:
+	Expression * low, * high;
 };
 
@@ -640,13 +640,13 @@
   public:
 	UntypedTupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
-	UntypedTupleExpr( const UntypedTupleExpr &other );
+	UntypedTupleExpr( const UntypedTupleExpr & other );
 	virtual ~UntypedTupleExpr();
 
 	std::list<Expression*>& get_exprs() { return exprs; }
 
-	virtual UntypedTupleExpr *clone() const { return new UntypedTupleExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual UntypedTupleExpr * clone() const { return new UntypedTupleExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
 	std::list<Expression*> exprs;
@@ -657,13 +657,13 @@
   public:
 	TupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
-	TupleExpr( const TupleExpr &other );
+	TupleExpr( const TupleExpr & other );
 	virtual ~TupleExpr();
 
 	std::list<Expression*>& get_exprs() { return exprs; }
 
-	virtual TupleExpr *clone() const { return new TupleExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual TupleExpr * clone() const { return new TupleExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
 	std::list<Expression*> exprs;
@@ -674,16 +674,16 @@
   public:
 	TupleIndexExpr( Expression * tuple, unsigned int index );
-	TupleIndexExpr( const TupleIndexExpr &other );
+	TupleIndexExpr( const TupleIndexExpr & other );
 	virtual ~TupleIndexExpr();
 
 	Expression * get_tuple() const { return tuple; }
 	int get_index() const { return index; }
-	TupleIndexExpr * set_tuple( Expression *newValue ) { tuple = newValue; return this; }
+	TupleIndexExpr * set_tuple( Expression * newValue ) { tuple = newValue; return this; }
 	TupleIndexExpr * set_index( unsigned int newValue ) { index = newValue; return this; }
 
-	virtual TupleIndexExpr *clone() const { return new TupleIndexExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual TupleIndexExpr * clone() const { return new TupleIndexExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
 	Expression * tuple;
@@ -695,16 +695,16 @@
   public:
 	MemberTupleExpr( Expression * member, Expression * aggregate, Expression * _aname = nullptr );
-	MemberTupleExpr( const MemberTupleExpr &other );
+	MemberTupleExpr( const MemberTupleExpr & other );
 	virtual ~MemberTupleExpr();
 
 	Expression * get_member() const { return member; }
 	Expression * get_aggregate() const { return aggregate; }
-	MemberTupleExpr * set_member( Expression *newValue ) { member = newValue; return this; }
-	MemberTupleExpr * set_aggregate( Expression *newValue ) { aggregate = newValue; return this; }
-
-	virtual MemberTupleExpr *clone() const { return new MemberTupleExpr( *this ); }
-	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;
+	MemberTupleExpr * set_member( Expression * newValue ) { member = newValue; return this; }
+	MemberTupleExpr * set_aggregate( Expression * newValue ) { aggregate = newValue; return this; }
+
+	virtual MemberTupleExpr * clone() const { return new MemberTupleExpr( * this ); }
+	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;
   private:
 	Expression * member;
@@ -716,5 +716,5 @@
   public:
 	TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname = nullptr );
-	TupleAssignExpr( const TupleAssignExpr &other );
+	TupleAssignExpr( const TupleAssignExpr & other );
 	virtual ~TupleAssignExpr();
 
@@ -722,8 +722,8 @@
 	StmtExpr * get_stmtExpr() const { return stmtExpr; }
 
-	virtual TupleAssignExpr *clone() const { return new TupleAssignExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual TupleAssignExpr * clone() const { return new TupleAssignExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
 	StmtExpr * stmtExpr = nullptr;
@@ -733,5 +733,5 @@
 class StmtExpr : public Expression {
 public:
-	StmtExpr( CompoundStmt *statements );
+	StmtExpr( CompoundStmt * statements );
 	StmtExpr( const StmtExpr & other );
 	virtual ~StmtExpr();
@@ -743,8 +743,8 @@
 	std::list< Expression * > & get_dtors() { return dtors; }
 
-	virtual StmtExpr *clone() const { return new StmtExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual StmtExpr * clone() const { return new StmtExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
 private:
 	CompoundStmt * statements;
@@ -770,8 +770,8 @@
 	int get_id() const { return id; }
 
-	virtual UniqueExpr *clone() const { return new UniqueExpr( *this ); }
-	virtual void accept( Visitor &v ) { v.visit( this ); }
-	virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual UniqueExpr * clone() const { return new UniqueExpr( * this ); }
+	virtual void accept( Visitor & v ) { v.visit( this ); }
+	virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+	virtual void print( std::ostream & os, int indent = 0 ) const;
 private:
 	Expression * expr;