Changeset 85521c7 for src/ResolvExpr

Timestamp:

Feb 1, 2018, 5:40:01 PM (8 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, stuck-waitfor-destruct, with_gc

Children:

0188a0bc

Parents:

d0a045c7 (diff), 33c0ce8 (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

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (1 diff)
• Resolver.cc (modified) (7 diffs)

src/ResolvExpr/AlternativeFinder.cc

@@ -1563 +1563 @@
                 // find alternatives for condition
                 AlternativeFinder firstFinder( indexer, env );
-                firstFinder.findWithAdjustment( conditionalExpr->get_arg1() );
+                firstFinder.findWithAdjustment( conditionalExpr->arg1 );
                 if ( firstFinder.alternatives.empty() ) return;
                 // find alternatives for true expression
                 AlternativeFinder secondFinder( indexer, env );
-                secondFinder.findWithAdjustment( conditionalExpr->get_arg2() );
+                secondFinder.findWithAdjustment( conditionalExpr->arg2 );
                 if ( secondFinder.alternatives.empty() ) return;
                 // find alterantives for false expression
                 AlternativeFinder thirdFinder( indexer, env );
-                thirdFinder.findWithAdjustment( conditionalExpr->get_arg3() );
+                thirdFinder.findWithAdjustment( conditionalExpr->arg3 );
                 if ( thirdFinder.alternatives.empty() ) return;
-                for ( AltList::const_iterator first = firstFinder.alternatives.begin(); first != firstFinder.alternatives.end(); ++first ) {
-                        for ( AltList::const_iterator second = secondFinder.alternatives.begin(); second != secondFinder.alternatives.end(); ++second ) {
-                                for ( AltList::const_iterator third = thirdFinder.alternatives.begin(); third != thirdFinder.alternatives.end(); ++third ) {
+                for ( const Alternative & first : firstFinder.alternatives ) {
+                        for ( const Alternative & second : secondFinder.alternatives ) {
+                                for ( const Alternative & third : thirdFinder.alternatives ) {
                                         TypeEnvironment compositeEnv;
-                                        compositeEnv.simpleCombine( first->env );
-                                        compositeEnv.simpleCombine( second->env );
-                                        compositeEnv.simpleCombine( third->env );
+                                        compositeEnv.simpleCombine( first.env );
+                                        compositeEnv.simpleCombine( second.env );
+                                        compositeEnv.simpleCombine( third.env );
 
                                         // unify true and false types, then infer parameters to produce new alternatives
                                         OpenVarSet openVars;
                                         AssertionSet needAssertions, haveAssertions;
-                                        Alternative newAlt( 0, compositeEnv, first->cost + second->cost + third->cost );
+                                        Alternative newAlt( 0, compositeEnv, first.cost + second.cost + third.cost );
                                         Type* commonType = nullptr;
-                                        if ( unify( second->expr->get_result(), third->expr->get_result(), newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
-                                                ConditionalExpr *newExpr = new ConditionalExpr( first->expr->clone(), second->expr->clone(), third->expr->clone() );
-                                                newExpr->set_result( commonType ? commonType : second->expr->get_result()->clone() );
+                                        if ( unify( second.expr->result, third.expr->result, newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
+                                                ConditionalExpr *newExpr = new ConditionalExpr( first.expr->clone(), second.expr->clone(), third.expr->clone() );
+                                                newExpr->result = commonType ? commonType : second.expr->result->clone();
                                                 // convert both options to the conditional result type
                                                 newAlt.cost += computeExpressionConversionCost( newExpr->arg2, newExpr->result, indexer, newAlt.env );

src/ResolvExpr/Resolver.cc

@@ -82 +82 @@
                 void previsit( ConstructorInit *ctorInit );
           private:
-        typedef std::list< Initializer * >::iterator InitIterator;
+                typedef std::list< Initializer * >::iterator InitIterator;
 
                 template< typename PtrType >
                 void handlePtrType( PtrType * type );
 
-          void resolveAggrInit( ReferenceToType *, InitIterator &, InitIterator & );
-          void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator &, TypeSubstitution sub );
-          void fallbackInit( ConstructorInit * ctorInit );
+                void resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts );
+                void fallbackInit( ConstructorInit * ctorInit );
 
                 Type * functionReturn = nullptr;
@@ -269 +268 @@
                 std::cerr << std::endl;
 #endif
-                Type *new_type = resolveTypeof( functionDecl->get_type(), indexer );
+                Type *new_type = resolveTypeof( functionDecl->type, indexer );
                 functionDecl->set_type( new_type );
                 GuardValue( functionReturn );
-                functionReturn = ResolvExpr::extractResultType( functionDecl->get_functionType() );
+                functionReturn = ResolvExpr::extractResultType( functionDecl->type );
+
+                {
+                        // resolve with-exprs with parameters in scope and add any newly generated declarations to the
+                        // front of the function body.
+                        auto guard = makeFuncGuard( [this]() { indexer.enterScope(); }, [this](){ indexer.leaveScope(); } );
+                        indexer.addFunctionType( functionDecl->type );
+                        std::list< Statement * > newStmts;
+                        resolveWithExprs( functionDecl->withExprs, newStmts );
+                        functionDecl->statements->kids.splice( functionDecl->statements->kids.begin(), newStmts );
+                }
         }
 
@@ -279 +288 @@
                 // xxx - it might be necessary to somehow keep the information from this environment, but I can't currently
                 // see how it's useful.
-                for ( Declaration * d : functionDecl->get_functionType()->get_parameters() ) {
+                for ( Declaration * d : functionDecl->type->parameters ) {
                         if ( ObjectDecl * obj = dynamic_cast< ObjectDecl * >( d ) ) {
-                                if ( SingleInit * init = dynamic_cast< SingleInit * >( obj->get_init() ) ) {
-                                        delete init->get_value()->get_env();
-                                        init->get_value()->set_env( nullptr );
+                                if ( SingleInit * init = dynamic_cast< SingleInit * >( obj->init ) ) {
+                                        delete init->value->env;
+                                        init->value->env = nullptr;
                                 }
                         }
@@ -584 +593 @@
         }
 
-
-        void Resolver::previsit( WithStmt * withStmt ) {
-                for ( Expression *& expr : withStmt->exprs )  {
+        void Resolver::resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts ) {
+                for ( Expression *& expr : withExprs )  {
                         // only struct- and union-typed expressions are viable candidates
                         findKindExpression( expr, indexer, "with statement", isStructOrUnion );
@@ -595 +603 @@
                                 ObjectDecl * tmp = ObjectDecl::newObject( tmpNamer.newName(), expr->result->clone(), new SingleInit( expr ) );
                                 expr = new VariableExpr( tmp );
-                                stmtsToAddBefore.push_back( new DeclStmt( tmp ) );
+                                newStmts.push_back( new DeclStmt( tmp ) );
                                 if ( InitTweak::isConstructable( tmp->type ) ) {
                                         // generate ctor/dtor and resolve them
@@ -603 +611 @@
                         }
                 }
+        }
+
+        void Resolver::previsit( WithStmt * withStmt ) {
+                resolveWithExprs( withStmt->exprs, stmtsToAddBefore );
         }
 
@@ -716 +728 @@
                 PassVisitor<Resolver> resolver( indexer );
                 stmtExpr->accept( resolver );
+                stmtExpr->computeResult();
         }