Changeset 907eccb for src/SynTree

Timestamp:

Dec 22, 2016, 3:23:49 PM (7 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:

4c8621ac

Parents:

0c286cf

Message:

added UntypedTupleExpr? to better differentiate typed and untyped contexts, simplifying some code

Location:

src/SynTree

Files:

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

src/SynTree/Expression.h

@@ -634 +634 @@
 };
 
+/// UntypedTupleExpr represents a tuple expression ( [a, b, c] ) before resolution
+class UntypedTupleExpr : public Expression {
+  public:
+        UntypedTupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
+        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;
+  private:
+        std::list<Expression*> exprs;
+};
+
 /// TupleExpr represents a tuple expression ( [a, b, c] )
 class TupleExpr : public Expression {
   public:
-        TupleExpr( const std::list< Expression * > & exprs = std::list< Expression * >(), Expression *_aname = nullptr );
+        TupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
         TupleExpr( const TupleExpr &other );
         virtual ~TupleExpr();
 
-        void set_exprs( std::list<Expression*> newValue ) { exprs = newValue; }
         std::list<Expression*>& get_exprs() { return exprs; }
 

src/SynTree/Mutator.cc

@@ -345 +345 @@
 Expression* Mutator::mutate( ImplicitCopyCtorExpr *impCpCtorExpr ) {
         impCpCtorExpr->set_env( maybeMutate( impCpCtorExpr->get_env(), *this ) );
+        impCpCtorExpr->set_result( maybeMutate( impCpCtorExpr->get_result(), *this ) );
         impCpCtorExpr->set_callExpr( maybeMutate( impCpCtorExpr->get_callExpr(), *this ) );
         mutateAll( impCpCtorExpr->get_tempDecls(), *this );
@@ -378 +379 @@
         rangeExpr->set_high( maybeMutate( rangeExpr->get_high(), *this ) );
         return rangeExpr;
+}
+
+Expression *Mutator::mutate( UntypedTupleExpr *tupleExpr ) {
+        tupleExpr->set_env( maybeMutate( tupleExpr->get_env(), *this ) );
+        tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
+        mutateAll( tupleExpr->get_exprs(), *this );
+        return tupleExpr;
 }
 

src/SynTree/Mutator.h

@@ -78 +78 @@
         virtual Expression* mutate( UntypedValofExpr *valofExpr );
         virtual Expression* mutate( RangeExpr *rangeExpr );
+        virtual Expression* mutate( UntypedTupleExpr *tupleExpr );
         virtual Expression* mutate( TupleExpr *tupleExpr );
         virtual Expression* mutate( TupleIndexExpr *tupleExpr );

src/SynTree/SynTree.h

@@ -83 +83 @@
 class UntypedValofExpr;
 class RangeExpr;
+class UntypedTupleExpr;
 class TupleExpr;
 class TupleIndexExpr;

src/SynTree/TupleExpr.cc

@@ -21 +21 @@
 #include "VarExprReplacer.h"
 
+UntypedTupleExpr::UntypedTupleExpr( const std::list< Expression * > & exprs, Expression *_aname ) : Expression( _aname ), exprs( exprs ) {
+}
+
+UntypedTupleExpr::UntypedTupleExpr( const UntypedTupleExpr &other ) : Expression( other ) {
+        cloneAll( other.exprs, exprs );
+}
+
+UntypedTupleExpr::~UntypedTupleExpr() {
+        deleteAll( exprs );
+}
+
+void UntypedTupleExpr::print( std::ostream &os, int indent ) const {
+        os << "Untyped Tuple:" << std::endl;
+        printAll( exprs, os, indent+2 );
+        Expression::print( os, indent );
+}
+
 TupleExpr::TupleExpr( const std::list< Expression * > & exprs, Expression *_aname ) : Expression( _aname ), exprs( exprs ) {
-        if ( ! exprs.empty() ) {
-                if ( std::all_of( exprs.begin(), exprs.end(), [](Expression * expr) { return expr->get_result(); } ) ) {
-                        set_result( Tuples::makeTupleType( exprs ) );
-                }
-        }
+        set_result( Tuples::makeTupleType( exprs ) );
 }
 
@@ -45 +58 @@
 TupleIndexExpr::TupleIndexExpr( Expression * tuple, unsigned int index ) : tuple( tuple ), index( index )  {
         TupleType * type = safe_dynamic_cast< TupleType * >( tuple->get_result() );
-        assert( type->size() > index );
+        assertf( type->size() > index, "TupleIndexExpr index out of bounds: tuple size %d, requested index %d", type->size(), index );
         set_result( (*std::next( type->get_types().begin(), index ))->clone() );
         get_result()->set_isLvalue( type->get_isLvalue() );

src/SynTree/Visitor.cc

@@ -273 +273 @@
 
 void Visitor::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
+        maybeAccept( impCpCtorExpr->get_result(), *this );
         maybeAccept( impCpCtorExpr->get_callExpr(), *this );
         acceptAll( impCpCtorExpr->get_tempDecls(), *this );
@@ -298 +299 @@
         maybeAccept( rangeExpr->get_low(), *this );
         maybeAccept( rangeExpr->get_high(), *this );
+}
+
+void Visitor::visit( UntypedTupleExpr *tupleExpr ) {
+        maybeAccept( tupleExpr->get_result(), *this );
+        acceptAll( tupleExpr->get_exprs(), *this );
 }
 

src/SynTree/Visitor.h

@@ -78 +78 @@
         virtual void visit( UntypedValofExpr *valofExpr );
         virtual void visit( RangeExpr *rangeExpr );
+        virtual void visit( UntypedTupleExpr *tupleExpr );
         virtual void visit( TupleExpr *tupleExpr );
         virtual void visit( TupleIndexExpr *tupleExpr );