Changeset 9236060 for src/GenPoly/Lvalue.cc

Timestamp:

Aug 14, 2017, 2:03:39 PM (5 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

aaron-thesis, arm-eh, 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, resolv-new, with_gc

Children:

74b007ba

Parents:

fd344aa (diff), 54cd58b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into references

File:

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

src/GenPoly/Lvalue.cc

@@ -30 +30 @@
 
 #include "ResolvExpr/Resolver.h"
+#include "ResolvExpr/TypeEnvironment.h"
 #include "ResolvExpr/typeops.h"
+#include "ResolvExpr/Unify.h"
 
 #include "Common/UniqueName.h"
@@ -64 +66 @@
 
                 struct ReferenceConversions final {
-                        void premutate( AddressExpr * addrExpr );
-
                         Expression * postmutate( CastExpr * castExpr );
                         Expression * postmutate( AddressExpr * addrExpr );
@@ -89 +89 @@
                 struct GeneralizedLvalue final : public WithVisitorRef<GeneralizedLvalue> {
                         Expression * postmutate( AddressExpr * addressExpr );
+                        Expression * postmutate( MemberExpr * memExpr );
+
+                        template<typename Func>
+                        Expression * applyTransformation( Expression * expr, Expression * arg, Func mkExpr );
                 };
 
@@ -133 +137 @@
                 // from this point forward, no other pass should create reference types.
                 referencesEliminated = true;
+        }
+
+        Expression * generalizedLvalue( Expression * expr ) {
+                PassVisitor<GeneralizedLvalue> genLval;
+                return expr->acceptMutator( genLval );
         }
 
@@ -359 +368 @@
                 }
 
-                Expression * GeneralizedLvalue::postmutate( AddressExpr * 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();
-                                Expression * ret = new CommaExpr( arg1, (new AddressExpr( arg2 ))->acceptMutator( *visitor ) );
-                                ret->set_env( addrExpr->get_env() );
-                                addrExpr->set_env( nullptr );
-                                delete addrExpr;
-                                return ret;
-                        } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( addrExpr->get_arg() ) ) {
+                                Expression * ret = new CommaExpr( arg1, mkExpr( arg2 )->acceptMutator( *visitor ) );
+                                ret->set_env( expr->get_env() );
+                                expr->set_env( nullptr );
+                                delete expr;
+                                return ret;
+                        } 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();
-                                Expression * ret = new ConditionalExpr( arg1, (new AddressExpr( arg2 ))->acceptMutator( *visitor ), (new AddressExpr( arg3 ))->acceptMutator( *visitor ) );
-                                ret->set_env( addrExpr->get_env() );
-                                addrExpr->set_env( nullptr );
-                                delete addrExpr;
-                                return ret;
-                        }
-                        return addrExpr;
+                                ConditionalExpr * ret = new ConditionalExpr( arg1, mkExpr( arg2 )->acceptMutator( *visitor ), mkExpr( arg3 )->acceptMutator( *visitor ) );
+                                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;
+                        }
+                        return expr;
+                }
+
+                Expression * GeneralizedLvalue::postmutate( MemberExpr * memExpr ) {
+                        return applyTransformation( memExpr, memExpr->get_aggregate(), [=]( Expression * aggr ) { return new MemberExpr( memExpr->get_member(), aggr ); } );
+                }
+
+                Expression * GeneralizedLvalue::postmutate( AddressExpr * addrExpr ) {
+                        return applyTransformation( addrExpr, addrExpr->get_arg(), []( Expression * arg ) { return new AddressExpr( arg ); } );
                 }