Changes in src/SynTree/Expression.cc [3b58d91:b6fe7e6]

File:

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

src/SynTree/Expression.cc

@@ -28 +28 @@
 #include "TypeSubstitution.h"
 #include "Common/utility.h"
+#include "InitTweak/InitTweak.h"
 
 
@@ -310 +311 @@
 }
 
-UntypedMemberExpr::UntypedMemberExpr( Expression * _member, Expression *_aggregate, Expression *_aname ) :
+UntypedMemberExpr::UntypedMemberExpr( std::string _member, Expression *_aggregate, Expression *_aname ) :
                 Expression( _aname ), member(_member), aggregate(_aggregate) {}
 
 UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr &other ) :
-                Expression( other ), member( maybeClone( other.member ) ), aggregate( maybeClone( other.aggregate ) ) {
+                Expression( other ), member( other.member ), aggregate( maybeClone( other.aggregate ) ) {
 }
 
 UntypedMemberExpr::~UntypedMemberExpr() {
         delete aggregate;
-        delete member;
 }
 
 void UntypedMemberExpr::print( std::ostream &os, int indent ) const {
-        os << "Untyped Member Expression, with field: " << std::endl;
-        get_member()->print(os, indent+4);
-        os << std::string( indent+2, ' ' );
+        os << "Untyped Member Expression, with field: " << get_member();
 
         Expression *agg = get_aggregate();
-        os << "from aggregate: " << std::endl;
+        os << ", from aggregate: ";
         if (agg != 0) {
-                os << std::string( indent + 4, ' ' );
-                agg->print(os, indent + 4);
+                os << std::string( indent + 2, ' ' );
+                agg->print(os, indent + 2);
         }
         os << std::string( indent+2, ' ' );
@@ -496 +494 @@
 
 void ImplicitCopyCtorExpr::print( std::ostream &os, int indent ) const {
-        os << std::string( indent, ' ' ) <<  "Implicit Copy Constructor Expression: " << std::endl;
+        os <<  "Implicit Copy Constructor Expression: " << std::endl;
         assert( callExpr );
         callExpr->print( os, indent + 2 );
@@ -506 +504 @@
 }
 
+
+ConstructorExpr::ConstructorExpr( Expression * callExpr ) : callExpr( callExpr ) {
+        // allow resolver to type a constructor used as an expression as if it has the same type as its first argument
+        assert( callExpr );
+        Expression * arg = InitTweak::getCallArg( callExpr, 0 );
+        assert( arg );
+        cloneAll( arg->get_results(), results );
+}
+
+ConstructorExpr::ConstructorExpr( const ConstructorExpr & other ) : Expression( other ), callExpr( maybeClone( other.callExpr ) ) {
+}
+
+ConstructorExpr::~ConstructorExpr() {
+        delete callExpr;
+}
+
+void ConstructorExpr::print( std::ostream &os, int indent ) const {
+        os <<  "Constructor Expression: " << std::endl;
+        assert( callExpr );
+        os << std::string( indent+2, ' ' );
+        callExpr->print( os, indent + 2 );
+        Expression::print( os, indent );
+}
+
+
+CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
+        add_result( type->clone() );
+}
+
+CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {}
+
+CompoundLiteralExpr::~CompoundLiteralExpr() {
+        delete initializer;
+        delete type;
+}
+
+void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
+        os << "Compound Literal Expression: " << std::endl;
+        if ( type ) type->print( os, indent + 2 );
+        if ( initializer ) initializer->print( os, indent + 2 );
+}
+
 UntypedValofExpr::UntypedValofExpr( const UntypedValofExpr & other ) : Expression( other ), body ( maybeClone( other.body ) ) {}
 
@@ -514 +554 @@
         if ( get_body() != 0 )
                 get_body()->print( os, indent + 2 );
-}
-
-
-CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
-        add_result( type->clone() );
-}
-
-CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {}
-
-CompoundLiteralExpr::~CompoundLiteralExpr() {
-        delete initializer;
-        delete type;
-}
-
-void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
-        os << "Compound Literal Expression: " << std::endl;
-        if ( type ) type->print( os, indent + 2 );
-        if ( initializer ) initializer->print( os, indent + 2 );
 }