Changeset 553f032f

Timestamp:

Sep 8, 2023, 5:15:41 PM (18 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

5cfb8b1

Parents:

2fa0237

Message:

Insert additional checks so that impossible, or just unimplemented, local control flow raises an error in CFA.

Files:

• src/ControlStruct/MultiLevelExit.cpp (modified) (10 diffs)
• tests/exceptions/.expect/finally-error.txt (deleted)
• tests/exceptions/.expect/try-ctrl-flow.txt (added)
• tests/exceptions/try-ctrl-flow.cfa (moved) (moved from tests/exceptions/finally-error.cfa) (2 diffs)

src/ControlStruct/MultiLevelExit.cpp ¶

@@ -10 +10 @@
 // Created On       : Mon Nov  1 13:48:00 2021
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Sep  6 12:00:00 2023
-// Update Count     : 35
+// Last Modified On : Fri Sep  8 17:04:00 2023
+// Update Count     : 36
 //
 
@@ -27 +27 @@
 
 namespace {
+
+/// The return context is used to remember if returns are allowed and if
+/// not, why not. It is the nearest local control flow blocking construct.
+enum ReturnContext {
+        MayReturn,
+        InTryWithHandler,
+        InResumeHandler,
+        InTerminateHandler,
+        InFinally,
+};
 
 class Entry {
@@ -126 +136 @@
         void previsit( const TryStmt * );
         void postvisit( const TryStmt * );
+        void previsit( const CatchClause * );
         void previsit( const FinallyClause * );
 
@@ -134 +145 @@
         vector<Entry> enclosing_control_structures;
         Label break_label;
-        bool inFinally;
+        ReturnContext ret_context;
 
         template<typename LoopNode>
@@ -144 +155 @@
                 const list<ptr<Stmt>> & kids, bool caseClause );
 
+        void enterSealedContext( ReturnContext );
+
         template<typename UnaryPredicate>
         auto findEnclosingControlStructure( UnaryPredicate pred ) {
@@ -157 +170 @@
 MultiLevelExitCore::MultiLevelExitCore( const LabelToStmt & lt ) :
         target_table( lt ), break_label( CodeLocation(), "" ),
-        inFinally( false )
+        ret_context( ReturnContext::MayReturn )
 {}
 
@@ -488 +501 @@
 
 void MultiLevelExitCore::previsit( const ReturnStmt * stmt ) {
-        if ( inFinally ) {
-                SemanticError( stmt->location, "'return' may not appear in a finally clause" );
-        }
+        char const * context;
+        switch ( ret_context ) {
+        case ReturnContext::MayReturn:
+                return;
+        case ReturnContext::InTryWithHandler:
+                context = "try statement with a catch clause";
+                break;
+        case ReturnContext::InResumeHandler:
+                context = "catchResume clause";
+                break;
+        case ReturnContext::InTerminateHandler:
+                context = "catch clause";
+                break;
+        case ReturnContext::InFinally:
+                context = "finally clause";
+                break;
+        default:
+                assert(0);
+        }
+        SemanticError( stmt->location, toString( "'return' may not appear in a ", context ) );
 }
 
@@ -500 +530 @@
                 GuardAction([this](){ enclosing_control_structures.pop_back(); } );
         }
+
+        // Try statements/try blocks are only sealed with a termination handler.
+        for ( auto clause : stmt->handlers ) {
+                if ( ast::Terminate == clause->kind ) {
+                        return enterSealedContext( ReturnContext::InTryWithHandler );
+                }
+        }
 }
 
@@ -512 +549 @@
 }
 
+void MultiLevelExitCore::previsit( const CatchClause * clause ) {
+        ReturnContext context = ( ast::Terminate == clause->kind )
+                ? ReturnContext::InTerminateHandler : ReturnContext::InResumeHandler;
+        enterSealedContext( context );
+}
+
 void MultiLevelExitCore::previsit( const FinallyClause * ) {
-        GuardAction([this, old = std::move( enclosing_control_structures)](){ enclosing_control_structures = std::move(old); });
-        enclosing_control_structures = vector<Entry>();
-        GuardValue( inFinally ) = true;
+        enterSealedContext( ReturnContext::InFinally );
 }
 
@@ -617 +658 @@
 }
 
+void MultiLevelExitCore::enterSealedContext( ReturnContext enter_context ) {
+        GuardAction([this, old = std::move(enclosing_control_structures)](){ enclosing_control_structures = std::move(old); });
+        enclosing_control_structures = vector<Entry>();
+        GuardValue( ret_context ) = enter_context;
+}
+
 } // namespace
 

tests/exceptions/try-ctrl-flow.cfa ¶

@@ -1 @@
-// All of these should be caught as long as the check remains in the same
-// pass. (Although not even all of the checks are in place yet.)
+// Check all the local control flow structures that are "sealed" by some the
+// try statement clauses; where structured programming is stricter.
 
 void break_in_finally() {
@@ -151 +151 @@
 }
 
+// Now just use return to test the other try control flow interactions.
+
+exception nil_exception {};
+
+void return_in_try_with_catch() {
+        try {
+                return;
+        } catch (nil_exception *) {
+                ;
+        }
+}
+
+// Allowed.
+void return_in_try_with_catchReturn() {
+        try {
+                return;
+        } catchResume (nil_exception *) {
+                ;
+        }
+}
+
+// Allowed.
+void return_in_try_with_finally() {
+        try {
+                return;
+        } finally {
+                ;
+        }
+}
+
+void return_in_catch() {
+        try {
+                ;
+        } catch (nil_exception *) {
+                return;
+        }
+}
+
+void return_in_catchResume() {
+        try {
+                ;
+        } catchResume (nil_exception *) {
+                return;
+        }
+}
+
 void main() {
         // Should not compile.