Changeset 9519aba

Timestamp:

Jun 4, 2019, 5:53:24 PM (5 years ago)

Author:

Aaron Moss <a3moss@…>

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:

1346914

Parents:

9a19608

Message:

Port FindOpenVars? to new AST

File:

• src/ResolvExpr/FindOpenVars.cc (modified) (6 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; } );
+                        }
+
+                };
         }
 
@@ -97 +138 @@
                         const ast::Type * type, ast::OpenVarSet & open, ast::OpenVarSet & closed, 
                         ast::AssertionSet & need, ast::AssertionSet & have, FirstMode firstIsOpen ) {
-                #warning unimplemented
-                (void)type; (void)open; (void)closed; (void)need; (void)have; (void)firstIsOpen;
-                assert(false);
+                ast::Pass< FindOpenVars_new > finder{ open, closed, need, have, firstIsOpen };
+                type->accept( finder );
         }
 } // namespace ResolvExpr