Changes in src/SynTree/Expression.cc [b4f8808:d807ca28]

File:

• src/SynTree/Expression.cc (modified) (52 diffs)

src/SynTree/Expression.cc

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