Changes in src/ResolvExpr/FindOpenVars.cc [85dac33:ce7ed2c]

File:

• src/ResolvExpr/FindOpenVars.cc (modified) (7 diffs)

src/ResolvExpr/FindOpenVars.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 09:42:48 2015
-// Last Modified By : Andrew
-// Last Modified On : Fri Jul 12 14:18:00 2019
-// Update Count     : 4
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 09:45:25 2015
+// Update Count     : 3
 //
 
@@ -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 ...
@@ -26 +24 @@
 
 namespace ResolvExpr {
-        struct FindOpenVars_old : public WithGuards {
-                FindOpenVars_old( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
+        struct FindOpenVars : public WithGuards {
+                FindOpenVars( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
 
-                void previsit( const PointerType * pointerType );
-                void previsit( const ArrayType * arrayType );
-                void previsit( const FunctionType * functionType );
-                void previsit( const TupleType * tupleType );
+                void previsit( PointerType * pointerType );
+                void previsit( ArrayType * arrayType );
+                void previsit( FunctionType * functionType );
+                void previsit( TupleType * tupleType );
 
-                void common_action( const Type *type );
+                void common_action( Type *type );
 
                 OpenVarSet &openVars, &closedVars;
@@ -41 +39 @@
         };
 
-        void findOpenVars( const Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen ) {
-                PassVisitor<FindOpenVars_old> finder( openVars, closedVars, needAssertions, haveAssertions, firstIsOpen );
+        void findOpenVars( Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen ) {
+                PassVisitor<FindOpenVars> finder( openVars, closedVars, needAssertions, haveAssertions, firstIsOpen );
                 type->accept( finder );
         }
 
-        FindOpenVars_old::FindOpenVars_old( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen )
+        FindOpenVars::FindOpenVars( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen )
                 : openVars( openVars ), closedVars( closedVars ), needAssertions( needAssertions ), haveAssertions( haveAssertions ), nextIsOpen( firstIsOpen ) {
         }
 
-        void FindOpenVars_old::common_action( const Type * type ) {
+        void FindOpenVars::common_action( Type *type ) {
                 if ( nextIsOpen ) {
-                        for ( Type::ForallList::const_iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
+                        for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
                                 openVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
                                 for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
@@ -61 +59 @@
                         }
                 } else {
-                        for ( Type::ForallList::const_iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
+                        for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
                                 closedVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
                                 for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
@@ -78 +76 @@
         }
 
-        void FindOpenVars_old::previsit(const PointerType * pointerType) {
+        void FindOpenVars::previsit(PointerType *pointerType) {
                 common_action( pointerType );
         }
 
-        void FindOpenVars_old::previsit(const ArrayType * arrayType) {
+        void FindOpenVars::previsit(ArrayType *arrayType) {
                 common_action( arrayType );
         }
 
-        void FindOpenVars_old::previsit(const FunctionType * functionType) {
+        void FindOpenVars::previsit(FunctionType *functionType) {
                 common_action( functionType );
                 nextIsOpen = ! nextIsOpen;
@@ -92 +90 @@
         }
 
-        void FindOpenVars_old::previsit(const TupleType * tupleType) {
+        void FindOpenVars::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