Changeset 5ded739

Timestamp:

Jan 18, 2017, 4:58:22 PM (8 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

f8b6d921

Parents:

44a81853

Message:

code formatting

File:

• src/SynTree/Expression.h (modified) (41 diffs)

src/SynTree/Expression.h

@@ -10 +10 @@
 // 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 +28 @@
 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 +61 @@
 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 +77 @@
 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 +101 @@
 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 +116 @@
         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 +130 @@
   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 +147 @@
 // 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 +168 @@
 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 +186 @@
 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 +205 @@
 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 +226 @@
 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 +247 @@
 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 +266 @@
   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 +283 @@
 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 +308 @@
 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 +333 @@
 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 +354 @@
 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 +375 @@
 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 +395 @@
 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 +423 @@
 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 +446 @@
 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 +470 @@
 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 +491 @@
 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 +509 @@
 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 +541 @@
         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 +548 @@
         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 +566 @@
         ~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 +581 @@
   public:
         CompoundLiteralExpr( Type * type, Initializer * initializer );
-        CompoundLiteralExpr( const CompoundLiteralExpr &other );
+        CompoundLiteralExpr( const CompoundLiteralExpr & other );
         virtual ~CompoundLiteralExpr();
 
@@ -590 +590 @@
         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 +606 @@
         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 +620 @@
 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 +640 @@
   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 +657 @@
   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 +674 @@
   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 +695 @@
   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 +716 @@
   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 +722 @@
         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 +733 @@
 class StmtExpr : public Expression {
 public:
-        StmtExpr( CompoundStmt *statements );
+        StmtExpr( CompoundStmt * statements );
         StmtExpr( const StmtExpr & other );
         virtual ~StmtExpr();
@@ -743 +743 @@
         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 +770 @@
         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;