Changeset 67130fe for src/ResolvExpr/FindOpenVars.cc

Timestamp:

Jun 4, 2019, 6:39:23 PM (5 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

c6a1e8a

Parents:

7564e10 (diff), 1346914 (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/FindOpenVars.cc (modified) (5 diffs)

src/ResolvExpr/FindOpenVars.cc

@@ -19 +19 @@
 #include <map>                    // for map<>::mapped_type
 
+#include "AST/Pass.hpp"
+#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"
 #include "SynTree/Declaration.h"  // for TypeDecl, DeclarationWithType (ptr ...
@@ -24 +26 @@
 
 namespace ResolvExpr {
-        struct FindOpenVars : public WithGuards {
-                FindOpenVars( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
+        struct FindOpenVars_old : public WithGuards {
+                FindOpenVars_old( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
 
                 void previsit( PointerType * pointerType );
@@ -40 +42 @@
 
         void findOpenVars( Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen ) {
-                PassVisitor<FindOpenVars> finder( openVars, closedVars, needAssertions, haveAssertions, firstIsOpen );
+                PassVisitor<FindOpenVars_old> finder( openVars, closedVars, needAssertions, haveAssertions, firstIsOpen );
                 type->accept( finder );
         }
 
-        FindOpenVars::FindOpenVars( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen )
+        FindOpenVars_old::FindOpenVars_old( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen )
                 : openVars( openVars ), closedVars( closedVars ), needAssertions( needAssertions ), haveAssertions( haveAssertions ), nextIsOpen( firstIsOpen ) {
         }
 
-        void FindOpenVars::common_action( Type *type ) {
+        void FindOpenVars_old::common_action( Type *type ) {
                 if ( nextIsOpen ) {
                         for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
@@ -76 +78 @@
         }
 
-        void FindOpenVars::previsit(PointerType *pointerType) {
+        void FindOpenVars_old::previsit(PointerType *pointerType) {
                 common_action( pointerType );
         }
 
-        void FindOpenVars::previsit(ArrayType *arrayType) {
+        void FindOpenVars_old::previsit(ArrayType *arrayType) {
                 common_action( arrayType );
         }
 
-        void FindOpenVars::previsit(FunctionType *functionType) {
+        void FindOpenVars_old::previsit(FunctionType *functionType) {
                 common_action( functionType );
                 nextIsOpen = ! nextIsOpen;
@@ -90 +92 @@
         }
 
-        void FindOpenVars::previsit(TupleType *tupleType) {
+        void FindOpenVars_old::previsit(TupleType *tupleType) {
                 common_action( tupleType );
+        }
+
+        namespace {
+                struct FindOpenVars_new final : public ast::WithGuards {
+                        ast::OpenVarSet & open;
+                        ast::OpenVarSet & closed;
+                        ast::AssertionSet & need;
+                        ast::AssertionSet & have;
+                        bool nextIsOpen;
+
+                        FindOpenVars_new( 
+                                ast::OpenVarSet & o, ast::OpenVarSet & c, ast::AssertionSet & n, 
+                                ast::AssertionSet & h, FirstMode firstIsOpen )
+                        : open( o ), closed( c ), need( n ), have( h ), nextIsOpen( firstIsOpen ) {}
+
+                        void previsit( const ast::FunctionType * type ) {
+                                // mark open/closed variables
+                                if ( nextIsOpen ) {
+                                        for ( const ast::TypeDecl * decl : type->forall ) {
+                                                open[ decl->name ] = ast::TypeDecl::Data{ decl };
+                                                for ( const ast::DeclWithType * assert : decl->assertions ) {
+                                                        need[ assert ].isUsed = false;
+                                                }
+                                        }
+                                } else {
+                                        for ( const ast::TypeDecl * decl : type->forall ) {
+                                                closed[ decl->name ] = ast::TypeDecl::Data{ decl };
+                                                for ( const ast::DeclWithType * assert : decl->assertions ) {
+                                                        have[ assert ].isUsed = false;
+                                                }
+                                        }
+                                }
+
+                                // flip open variables for contained function types
+                                nextIsOpen = ! nextIsOpen;
+                                GuardAction( [this](){ nextIsOpen = ! nextIsOpen; } );
+                        }
+
+                };
+        }
+
+        void findOpenVars( 
+                        const ast::Type * type, ast::OpenVarSet & open, ast::OpenVarSet & closed, 
+                        ast::AssertionSet & need, ast::AssertionSet & have, FirstMode firstIsOpen ) {
+                ast::Pass< FindOpenVars_new > finder{ open, closed, need, have, firstIsOpen };
+                type->accept( finder );
         }
 } // namespace ResolvExpr