Changeset c6c682cf

Timestamp:

Oct 29, 2020, 4:46:04 PM (4 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

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

Children:

3100754

Parents:

93068e53

Message:

This should make the value of Pass[Visitor]::inFunction match the expected value.

Location:

src

Files:

• AST/Pass.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (2 diffs)
• Common/PassVisitor.h (modified) (2 diffs)
• Common/PassVisitor.impl.h (modified) (6 diffs)

src/AST/Pass.hpp

@@ -296 +296 @@
 private:
         bool inFunction = false;
+        bool atFunctionTop = false;
 };
 

src/AST/Pass.impl.hpp

@@ -502 +502 @@
                                 // foralls are still in function type
                                 maybe_accept( node, &FunctionDecl::type );
-                                // function body needs to have the same scope as parameters - CompoundStmt will not enter
-                                // a new scope if inFunction is true
+                                // First remember that we are now within a function.
                                 ValueGuard< bool > oldInFunction( inFunction );
                                 inFunction = true;
+                                // The function body needs to have the same scope as parameters.
+                                // A CompoundStmt will not enter a new scope if atFunctionTop is true.
+                                ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                                atFunctionTop = true;
                                 maybe_accept( node, &FunctionDecl::stmts );
                                 maybe_accept( node, &FunctionDecl::attributes );
@@ -672 +675 @@
         VISIT_START( node );
         VISIT({
-                // do not enter a new scope if inFunction is true - needs to check old state before the assignment
-                auto guard1 = makeFuncGuard( [this, inFunctionCpy = this->inFunction]() {
-                        if ( ! inFunctionCpy ) __pass::symtab::enter(core, 0);
-                }, [this, inFunctionCpy = this->inFunction]() {
-                        if ( ! inFunctionCpy ) __pass::symtab::leave(core, 0);
+                // Do not enter (or leave) a new scope if atFunctionTop. Remember to save the result.
+                auto guard1 = makeFuncGuard( [this, enterScope = !this->atFunctionTop]() {
+                        if ( enterScope ) __pass::symtab::enter(core, 0);
+                }, [this, leaveScope = !this->atFunctionTop]() {
+                        if ( leaveScope ) __pass::symtab::leave(core, 0);
                 });
                 ValueGuard< bool > guard2( inFunction );

src/Common/PassVisitor.h

@@ -360 +360 @@
 private:
         bool inFunction = false;
+        bool atFunctionTop = false;
 
         template<typename pass_t> friend void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_t >& visitor );
@@ -532 +533 @@
 
         bool isInFunction() const {
-                return visitor->inFunction;
+                return visitor->isInFunction();
         }
 };

src/Common/PassVisitor.impl.h

@@ -532 +532 @@
                         indexerAddId( &func );
                         maybeAccept_impl( node->type, *this );
-                        // function body needs to have the same scope as parameters - CompoundStmt will not enter
-                        // a new scope if inFunction is true
+                        // First remember that we are now within a function.
                         ValueGuard< bool > oldInFunction( inFunction );
                         inFunction = true;
+                        // The function body needs to have the same scope as parameters.
+                        // A CompoundStmt will not enter a new scope if atFunctionTop is true.
+                        ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                        atFunctionTop = true;
                         maybeAccept_impl( node->statements, *this );
                         maybeAccept_impl( node->attributes, *this );
@@ -567 +570 @@
                         indexerAddId( &func );
                         maybeAccept_impl( node->type, *this );
-                        // function body needs to have the same scope as parameters - CompoundStmt will not enter
-                        // a new scope if inFunction is true
+                        // First remember that we are now within a function.
                         ValueGuard< bool > oldInFunction( inFunction );
                         inFunction = true;
+                        // The function body needs to have the same scope as parameters.
+                        // A CompoundStmt will not enter a new scope if atFunctionTop is true.
+                        ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                        atFunctionTop = true;
                         maybeAccept_impl( node->statements, *this );
                         maybeAccept_impl( node->attributes, *this );
@@ -601 +607 @@
                         indexerAddId( &func );
                         maybeMutate_impl( node->type, *this );
-                        // function body needs to have the same scope as parameters - CompoundStmt will not enter
-                        // a new scope if inFunction is true
+                        // First remember that we are now within a function.
                         ValueGuard< bool > oldInFunction( inFunction );
                         inFunction = true;
+                        // The function body needs to have the same scope as parameters.
+                        // A CompoundStmt will not enter a new scope if atFunctionTop is true.
+                        ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                        atFunctionTop = true;
                         maybeMutate_impl( node->statements, *this );
                         maybeMutate_impl( node->attributes, *this );
@@ -1007 +1016 @@
         VISIT_START( node );
         {
-                // do not enter a new scope if inFunction is true - needs to check old state before the assignment
-                ValueGuard< bool > oldInFunction( inFunction );
-                auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
+                // Do not enter a new scope if atFunctionTop is true, don't leave one either.
+                ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                auto guard1 = makeFuncGuard( [this, go = !atFunctionTop]() { if ( go ) indexerScopeEnter(); }, [this, go = !atFunctionTop]() { if ( go ) indexerScopeLeave(); } );
                 auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
-                inFunction = false;
+                atFunctionTop = false;
                 visitStatementList( node->kids );
         }
@@ -1021 +1030 @@
         VISIT_START( node );
         {
-                // do not enter a new scope if inFunction is true - needs to check old state before the assignment
-                ValueGuard< bool > oldInFunction( inFunction );
-                auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
+                // Do not enter a new scope if atFunctionTop is true, don't leave one either.
+                ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                auto guard1 = makeFuncGuard( [this, go = !atFunctionTop]() { if ( go ) indexerScopeEnter(); }, [this, go = !atFunctionTop]() { if ( go ) indexerScopeLeave(); } );
                 auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
-                inFunction = false;
+                atFunctionTop = false;
                 visitStatementList( node->kids );
         }
@@ -1035 +1044 @@
         MUTATE_START( node );
         {
-                // do not enter a new scope if inFunction is true - needs to check old state before the assignment
-                ValueGuard< bool > oldInFunction( inFunction );
-                auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
+                // Do not enter a new scope if atFunctionTop is true, don't leave one either.
+                ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                auto guard1 = makeFuncGuard( [this, go = !atFunctionTop]() { if ( go ) indexerScopeEnter(); }, [this, go = !atFunctionTop]() { if ( go ) indexerScopeLeave(); } );
                 auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
-                inFunction = false;
+                atFunctionTop = false;
                 mutateStatementList( node->kids );
         }