Changeset acd7c5dd for src/GenPoly/Lvalue.cc

Timestamp:

Aug 8, 2017, 2:49:47 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:

c92c09c

Parents:

56e49b0

Message:

Apply generalized lvalue pass to MemberExpr?

File:

• src/GenPoly/Lvalue.cc (modified) (4 diffs)

src/GenPoly/Lvalue.cc

@@ -27 +27 @@
 #include "SynTree/Mutator.h"
 #include "SymTab/Indexer.h"
+
 #include "ResolvExpr/Resolver.h"
+#include "ResolvExpr/TypeEnvironment.h"
 #include "ResolvExpr/typeops.h"
+#include "ResolvExpr/Unify.h"
 
 #include "Common/UniqueName.h"
@@ -60 +63 @@
                         typedef Mutator Parent;
 
+                        virtual Expression * mutate( MemberExpr * memExpr );
                         virtual Expression * mutate( AddressExpr * addressExpr );
+
+                        template<typename Func>
+                        Expression * applyTransformation( Expression * expr, Expression * arg, Func mkExpr );
                 };
         } // namespace
@@ -71 +78 @@
                 acceptAll( translationUnit, p2 );
                 mutateAll( translationUnit, genLval );
+        }
+
+        Expression * generalizedLvalue( Expression * expr ) {
+                GeneralizedLvalue genLval;
+                return expr->acceptMutator( genLval );
         }
 
@@ -163 +175 @@
                 }
 
-                Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) {
-                        addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) );
-                        if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( addrExpr->get_arg() ) ) {
+                template<typename Func>
+                Expression * GeneralizedLvalue::applyTransformation( Expression * expr, Expression * arg, Func mkExpr ) {
+                        if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( arg ) ) {
                                 Expression * arg1 = commaExpr->get_arg1()->clone();
                                 Expression * arg2 = commaExpr->get_arg2()->clone();
-                                delete addrExpr;
-                                return new CommaExpr( arg1, new AddressExpr( arg2 ) );
-                        } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( addrExpr->get_arg() ) ) {
+                                Expression * ret = new CommaExpr( arg1, mkExpr( arg2 ) );
+                                ret->set_env( expr->get_env() );
+                                expr->set_env( nullptr );
+                                delete expr;
+                                return ret->acceptMutator( *this );
+                        } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( arg ) ) {
                                 Expression * arg1 = condExpr->get_arg1()->clone();
                                 Expression * arg2 = condExpr->get_arg2()->clone();
                                 Expression * arg3 = condExpr->get_arg3()->clone();
-                                delete addrExpr;
-                                return new ConditionalExpr( arg1, new AddressExpr( arg2 ), new AddressExpr( arg3 ) );
+                                ConditionalExpr * ret = new ConditionalExpr( arg1, mkExpr( arg2 ), mkExpr( arg3 ) );
+                                ret->set_env( expr->get_env() );
+                                expr->set_env( nullptr );
+                                delete expr;
+
+                                // conditional expr type may not be either of the argument types, need to unify
+                                using namespace ResolvExpr;
+                                Type* commonType = nullptr;
+                                TypeEnvironment newEnv;
+                                AssertionSet needAssertions, haveAssertions;
+                                OpenVarSet openVars;
+                                unify( ret->get_arg2()->get_result(), ret->get_arg3()->get_result(), newEnv, needAssertions, haveAssertions, openVars, SymTab::Indexer(), commonType );
+                                ret->set_result( commonType ? commonType : ret->get_arg2()->get_result()->clone() );
+                                return ret->acceptMutator( *this );
                         }
-                        return addrExpr;
+                        return expr;
+                }
+
+                Expression * GeneralizedLvalue::mutate( MemberExpr * memExpr ) {
+                        Parent::mutate( memExpr );
+                        return applyTransformation( memExpr, memExpr->get_aggregate(), [=]( Expression * aggr ) { return new MemberExpr( memExpr->get_member(), aggr ); } );
+                }
+
+                Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) {
+                        addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) );
+                        return applyTransformation( addrExpr, addrExpr->get_arg(), []( Expression * arg ) { return new AddressExpr( arg ); } );
                 }
         } // namespace