Changeset 65197c2 for src/ResolvExpr/Resolver.cc

Timestamp:

Dec 5, 2017, 2:17:17 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

971d9f2, a85e44c, c13e8dc8

Parents:

12d2dc8 (diff), 866f560 (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' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/ResolvExpr/Resolver.cc (modified) (5 diffs)

src/ResolvExpr/Resolver.cc

@@ -26 +26 @@
 #include "Common/utility.h"              // for ValueGuard, group_iterate
 #include "CurrentObject.h"               // for CurrentObject
+#include "InitTweak/GenInit.h"
 #include "InitTweak/InitTweak.h"         // for isIntrinsicSingleArgCallStmt
 #include "RenameVars.h"                  // for RenameVars, global_renamer
@@ -40 +41 @@
 #include "SynTree/TypeSubstitution.h"    // for TypeSubstitution
 #include "SynTree/Visitor.h"             // for acceptAll, maybeAccept
+#include "Tuples/Tuples.h"
 #include "typeops.h"                     // for extractResultType
 #include "Unify.h"                       // for unify
@@ -46 +48 @@
 
 namespace ResolvExpr {
-        struct Resolver final : public WithIndexer, public WithGuards, public WithVisitorRef<Resolver>, public WithShortCircuiting {
+        struct Resolver final : public WithIndexer, public WithGuards, public WithVisitorRef<Resolver>, public WithShortCircuiting, public WithStmtsToAdd {
                 Resolver() {}
                 Resolver( const SymTab::Indexer & other ) {
@@ -74 +76 @@
                 void previsit( CatchStmt *catchStmt );
                 void previsit( WaitForStmt * stmt );
+                void previsit( WithStmt * withStmt );
 
                 void previsit( SingleInit *singleInit );
@@ -571 +574 @@
         }
 
+        bool isStructOrUnion( Type * t ) {
+                t = t->stripReferences();
+                return dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t );
+        }
+
+        void Resolver::previsit( WithStmt * withStmt ) {
+                for ( Expression *& expr : withStmt->exprs )  {
+                        TypeEnvironment env;
+                        AlternativeFinder finder( indexer, env );
+                        finder.findWithAdjustment( expr );
+
+                        // only struct- and union-typed expressions are viable candidates
+                        AltList candidates;
+                        for ( Alternative & alt : finder.get_alternatives() ) {
+                                if ( isStructOrUnion( alt.expr->result ) ) {
+                                        candidates.push_back( std::move( alt ) );
+                                }
+                        }
+
+                        // choose the lowest cost expression among the candidates
+                        AltList winners;
+                        findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
+                        if ( winners.size() == 0 ) {
+                                throw SemanticError( "No reasonable alternatives for with statement expression: ", expr );
+                        } else if ( winners.size() != 1 ) {
+                                std::ostringstream stream;
+                                stream << "Cannot choose between " << winners.size() << " alternatives for with statement expression\n";
+                                expr->print( stream );
+                                stream << "Alternatives are:\n";
+                                printAlts( winners, stream, 1 );
+                                throw SemanticError( stream.str() );
+                        }
+
+                        // there is one unambiguous interpretation - move the expression into the with statement
+                        Alternative & alt = winners.front();
+                        finishExpr( alt.expr, alt.env, expr->env );
+                        delete expr;
+                        expr = alt.expr;
+                        alt.expr = nullptr;
+
+                        // if with expression might be impure, create a temporary so that it is evaluated once
+                        if ( Tuples::maybeImpure( expr ) ) {
+                                static UniqueName tmpNamer( "_with_tmp_" );
+                                ObjectDecl * tmp = ObjectDecl::newObject( tmpNamer.newName(), expr->result->clone(), new SingleInit( expr ) );
+                                expr = new VariableExpr( tmp );
+                                stmtsToAddBefore.push_back( new DeclStmt( tmp ) );
+                                if ( InitTweak::isConstructable( tmp->type ) ) {
+                                        // generate ctor/dtor and resolve them
+                                        tmp->init = InitTweak::genCtorInit( tmp );
+                                        tmp->accept( *visitor );
+                                }
+                        }
+                }
+        }
+
         template< typename T >
         bool isCharType( T t ) {