Changeset b6fe7e6 for src/SynTree

Timestamp:

Sep 9, 2016, 1:58:07 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

03e3117

Parents:

d1969a6

Message:

make constructor expressions work, fix bug with using the wrong TypeEnvironment? on member exprs, remove many unnecessary ctor/dtors from the prelude

Location:

src/SynTree

Files:

• Expression.cc (modified) (4 diffs)
• Expression.h (modified) (2 diffs)
• Mutator.cc (modified) (2 diffs)
• Mutator.h (modified) (1 diff)
• SynTree.h (modified) (1 diff)
• Visitor.cc (modified) (2 diffs)
• Visitor.h (modified) (1 diff)

src/SynTree/Expression.cc

@@ -28 +28 @@
 #include "TypeSubstitution.h"
 #include "Common/utility.h"
+#include "InitTweak/InitTweak.h"
 
 
@@ -493 +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 );
@@ -503 +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 ) ) {}
 
@@ -511 +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 );
 }
 

src/SynTree/Expression.h

@@ -595 +595 @@
 };
 
+/// ConstructorExpr represents the use of a constructor in an expression context, e.g. int * x = malloc() { 5 };
+class ConstructorExpr : public Expression {
+public:
+        ConstructorExpr( Expression * callExpr );
+        ConstructorExpr( const ConstructorExpr & other );
+        ~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;
+private:
+        Expression * callExpr;
+};
+
+/// CompoundLiteralExpr represents a C99 'compound literal'
+class CompoundLiteralExpr : public Expression {
+  public:
+        CompoundLiteralExpr( Type * type, Initializer * initializer );
+        CompoundLiteralExpr( const CompoundLiteralExpr &other );
+        ~CompoundLiteralExpr();
+
+        Type * get_type() const { return type; }
+        void set_type( Type * t ) { type = t; }
+
+        Initializer * get_initializer() const { return initializer; }
+        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;
+  private:
+        Type * type;
+        Initializer * initializer;
+};
+
 /// ValofExpr represents a GCC 'lambda expression'
 class UntypedValofExpr : public Expression {
@@ -613 +653 @@
 };
 
-/// CompoundLiteralExpr represents a C99 'compound literal'
-class CompoundLiteralExpr : public Expression {
-  public:
-        CompoundLiteralExpr( Type * type, Initializer * initializer );
-        CompoundLiteralExpr( const CompoundLiteralExpr &other );
-        ~CompoundLiteralExpr();
-
-        Type * get_type() const { return type; }
-        void set_type( Type * t ) { type = t; }
-
-        Initializer * get_initializer() const { return initializer; }
-        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;
-  private:
-        Type * type;
-        Initializer * initializer;
-};
-
+/// RangeExpr represents a range e.g. '3 ... 5' or '1~10'
 class RangeExpr : public Expression {
   public:

src/SynTree/Mutator.cc

@@ -339 +339 @@
 }
 
-Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) {
-        mutateAll( valofExpr->get_results(), *this );
-        return valofExpr;
+Expression* Mutator::mutate( ConstructorExpr *ctorExpr ) {
+        mutateAll( ctorExpr->get_results(), *this );
+        ctorExpr->set_callExpr( maybeMutate( ctorExpr->get_callExpr(), *this ) );
+        return ctorExpr;
 }
 
@@ -349 +350 @@
         compLitExpr->set_initializer( maybeMutate( compLitExpr->get_initializer(), *this ) );
         return compLitExpr;
+}
+
+Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) {
+        mutateAll( valofExpr->get_results(), *this );
+        return valofExpr;
 }
 

src/SynTree/Mutator.h

@@ -76 +76 @@
         virtual Expression* mutate( AsmExpr *asmExpr );
         virtual Expression* mutate( ImplicitCopyCtorExpr *impCpCtorExpr );
+        virtual Expression* mutate( ConstructorExpr *ctorExpr );
+        virtual Expression* mutate( CompoundLiteralExpr *compLitExpr );
         virtual Expression* mutate( UntypedValofExpr *valofExpr );
-        virtual Expression* mutate( CompoundLiteralExpr *compLitExpr );
         virtual Expression* mutate( RangeExpr *rangeExpr );
 

src/SynTree/SynTree.h

@@ -81 +81 @@
 class AsmExpr;
 class ImplicitCopyCtorExpr;
+class ConstructorExpr;
+class CompoundLiteralExpr;
 class UntypedValofExpr;
-class CompoundLiteralExpr;
 class RangeExpr;
 

src/SynTree/Visitor.cc

@@ -287 +287 @@
 }
 
-void Visitor::visit( UntypedValofExpr *valofExpr ) {
-        acceptAll( valofExpr->get_results(), *this );
-        maybeAccept( valofExpr->get_body(), *this );
+void Visitor::visit( ConstructorExpr * ctorExpr ) {
+        acceptAll( ctorExpr->get_results(), *this );
+        maybeAccept( ctorExpr->get_callExpr(), *this );
 }
 
@@ -296 +296 @@
         maybeAccept( compLitExpr->get_type(), *this );
         maybeAccept( compLitExpr->get_initializer(), *this );
+}
+
+void Visitor::visit( UntypedValofExpr *valofExpr ) {
+        acceptAll( valofExpr->get_results(), *this );
+        maybeAccept( valofExpr->get_body(), *this );
 }
 

src/SynTree/Visitor.h

@@ -76 +76 @@
         virtual void visit( AsmExpr *asmExpr );
         virtual void visit( ImplicitCopyCtorExpr *impCpCtorExpr );
+        virtual void visit( ConstructorExpr * ctorExpr );
+        virtual void visit( CompoundLiteralExpr *compLitExpr );
         virtual void visit( UntypedValofExpr *valofExpr );
-        virtual void visit( CompoundLiteralExpr *compLitExpr );
         virtual void visit( RangeExpr *rangeExpr );