Changeset 6d44da1 for src/ResolvExpr

Timestamp:

Sep 25, 2018, 11:35:34 AM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer, pthread-emulation, qualifiedEnum

Children:

c6bbcdb

Parents:

341bb80 (diff), 7428ad9 (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 shared_library

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (2 diffs)
• Resolver.cc (modified) (9 diffs)
• Resolver.h (modified) (1 diff)
• TypeEnvironment.cc (modified) (6 diffs)

src/ResolvExpr/AlternativeFinder.cc

@@ -25 +25 @@
 #include <vector>                  // for vector
 
+#include "CompilationState.h"      // for resolvep
 #include "Alternative.h"           // for AltList, Alternative
 #include "AlternativeFinder.h"
@@ -49 +50 @@
 #include "typeops.h"               // for adjustExprType, polyCost, castCost
 
-extern bool resolvep;
 #define PRINT( text ) if ( resolvep ) { text }
 //#define DEBUG_COST

src/ResolvExpr/Resolver.cc

@@ -30 +30 @@
 #include "RenameVars.h"                  // for RenameVars, global_renamer
 #include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
-#include "ResolveTypeof.h"               // for resolveTypeof
 #include "Resolver.h"
 #include "SymTab/Autogen.h"              // for SizeType
@@ -57 +56 @@
                 void postvisit( FunctionDecl *functionDecl );
                 void previsit( ObjectDecl *objectDecll );
-                void previsit( TypeDecl *typeDecl );
                 void previsit( EnumDecl * enumDecl );
                 void previsit( StaticAssertDecl * assertDecl );
@@ -77 +75 @@
                 void previsit( CatchStmt *catchStmt );
                 void previsit( WaitForStmt * stmt );
-                void previsit( WithStmt * withStmt );
 
                 void previsit( SingleInit *singleInit );
@@ -88 +85 @@
                 void handlePtrType( PtrType * type );
 
-                void resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts );
                 void fallbackInit( ConstructorInit * ctorInit );
 
@@ -94 +90 @@
                 CurrentObject currentObject = nullptr;
                 bool inEnumDecl = false;
+        };
+
+        struct ResolveWithExprs : public WithIndexer, public WithGuards, public WithVisitorRef<ResolveWithExprs>, public WithShortCircuiting, public WithStmtsToAdd {
+                void previsit( FunctionDecl * );
+                void previsit( WithStmt * );
+
+                void resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts );
         };
 
@@ -302 +305 @@
         }
 
+
+        bool isStructOrUnion( const Alternative & alt ) {
+                Type * t = alt.expr->result->stripReferences();
+                return dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t );
+        }
+
+        void resolveWithExprs( std::list< Declaration * > & translationUnit ) {
+                PassVisitor<ResolveWithExprs> resolver;
+                acceptAll( translationUnit, resolver );
+        }
+
+        void ResolveWithExprs::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 );
+
+                        // 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 );
+                                newStmts.push_back( new DeclStmt( tmp ) );
+                                if ( InitTweak::isConstructable( tmp->type ) ) {
+                                        // generate ctor/dtor and resolve them
+                                        tmp->init = InitTweak::genCtorInit( tmp );
+                                        tmp->accept( *visitor );
+                                }
+                        }
+                }
+        }
+
+        void ResolveWithExprs::previsit( WithStmt * withStmt ) {
+                resolveWithExprs( withStmt->exprs, stmtsToAddBefore );
+        }
+
+        void ResolveWithExprs::previsit( FunctionDecl * functionDecl ) {
+                {
+                        // 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 );
+                        if ( functionDecl->statements ) {
+                                functionDecl->statements->kids.splice( functionDecl->statements->kids.begin(), newStmts );
+                        } else {
+                                assertf( functionDecl->withExprs.empty() && newStmts.empty(), "Function %s without a body has with-clause and/or generated with declarations.", functionDecl->name.c_str() );
+                        }
+                }
+        }
+
         void Resolver::previsit( ObjectDecl *objectDecl ) {
-                Type *new_type = resolveTypeof( objectDecl->get_type(), indexer );
-                objectDecl->set_type( new_type );
                 // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that class-variable
                 // initContext is changed multiple time because the LHS is analysed twice. The second analysis changes
@@ -334 +386 @@
         }
 
-        void Resolver::previsit( TypeDecl *typeDecl ) {
-                if ( typeDecl->get_base() ) {
-                        Type *new_type = resolveTypeof( typeDecl->get_base(), indexer );
-                        typeDecl->set_base( new_type );
-                } // if
-        }
-
         void Resolver::previsit( FunctionDecl *functionDecl ) {
 #if 0
@@ -347 +392 @@
                 std::cerr << std::endl;
 #endif
-                Type *new_type = resolveTypeof( functionDecl->type, indexer );
-                functionDecl->set_type( new_type );
                 GuardValue( functionReturn );
                 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 );
-                        if ( functionDecl->statements ) {
-                                functionDecl->statements->kids.splice( functionDecl->statements->kids.begin(), newStmts );
-                        } else {
-                                assertf( functionDecl->withExprs.empty() && newStmts.empty(), "Function %s without a body has with-clause and/or generated with declarations.", functionDecl->name.c_str() );
-                        }
-                }
         }
 
@@ -695 +724 @@
                         stmt->orelse.statement->accept( *visitor );
                 }
-        }
-
-        bool isStructOrUnion( const Alternative & alt ) {
-                Type * t = alt.expr->result->stripReferences();
-                return dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t );
-        }
-
-        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 );
-
-                        // 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 );
-                                newStmts.push_back( new DeclStmt( tmp ) );
-                                if ( InitTweak::isConstructable( tmp->type ) ) {
-                                        // generate ctor/dtor and resolve them
-                                        tmp->init = InitTweak::genCtorInit( tmp );
-                                        tmp->accept( *visitor );
-                                }
-                        }
-                }
-        }
-
-        void Resolver::previsit( WithStmt * withStmt ) {
-                resolveWithExprs( withStmt->exprs, stmtsToAddBefore );
         }
 

src/ResolvExpr/Resolver.h

@@ -38 +38 @@
         /// Searches expr and returns the first DeletedExpr found, otherwise nullptr
         DeletedExpr * findDeletedExpr( Expression * expr );
+        /// Resolves with-stmts and with-clauses on functions
+        void resolveWithExprs( std::list< Declaration * > & translationUnit );
 } // namespace ResolvExpr
 

src/ResolvExpr/TypeEnvironment.cc

@@ -69 +69 @@
         }
 
-        EqvClass::EqvClass( EqvClass &&other ) 
-        : vars{std::move(other.vars)}, type{other.type}, 
+        EqvClass::EqvClass( EqvClass &&other )
+        : vars{std::move(other.vars)}, type{other.type},
           allowWidening{std::move(other.allowWidening)}, data{std::move(other.data)} {
                   other.type = nullptr;
@@ -85 +85 @@
                 if ( this == &other ) return *this;
                 delete type;
-                
+
                 vars = std::move(other.vars);
                 type = other.type;
@@ -132 +132 @@
                         ++next;
                         std::set<std::string> intersection;
-                        std::set_intersection( i->vars.begin(), i->vars.end(), eqvClass.vars.begin(), eqvClass.vars.end(), 
+                        std::set_intersection( i->vars.begin(), i->vars.end(), eqvClass.vars.begin(), eqvClass.vars.end(),
                                 std::inserter( intersection, intersection.begin() ) );
                         if ( ! intersection.empty() ) { env.erase( i ); }
@@ -240 +240 @@
                         // ttype unifies with any tuple type
                         return dynamic_cast< TupleType * >( type ) || Tuples::isTtype( type );
+                  default:
+                        assertf(false, "Unhandled tyvar kind: %d", data.kind);
                 } // switch
                 return false;
@@ -245 +247 @@
 
         bool TypeEnvironment::bindVar( TypeInstType *typeInst, Type *bindTo, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
-                
+
                 // remove references from other, so that type variables can only bind to value types
                 bindTo = bindTo->stripReferences();
@@ -291 +293 @@
                 auto class1 = internal_lookup( var1->get_name() );
                 auto class2 = internal_lookup( var2->get_name() );
-                
+
                 // exit early if variables already bound together
                 if ( class1 != env.end() && class1 == class2 ) {