Changeset deda7e6 for src

Timestamp:

Sep 21, 2023, 10:15:58 PM (16 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

62c6cfa

Parents:

c1e66d9 (diff), 5a1ae14 (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

Location:

src

Files:

• AST/Util.cpp (modified) (3 diffs)
• ControlStruct/MultiLevelExit.cpp (modified) (10 diffs)
• GenPoly/GenPoly.cc (modified) (4 diffs)

src/AST/Util.cpp

@@ -104 +104 @@
         }
         assertf( false, "Member not found." );
+}
+
+template<typename node_t>
+void oneOfExprOrType( const node_t * node ) {
+        if ( node->expr ) {
+                assertf( node->expr && !node->type, "Exactly one of expr or type should be set." );
+        } else {
+                assertf( !node->expr && node->type, "Exactly one of expr or type should be set." );
+        }
 }
 
@@ -152 +161 @@
         }
 
+        void previsit( const SizeofExpr * node ) {
+                previsit( (const ParseNode *)node );
+                oneOfExprOrType( node );
+        }
+
+        void previsit( const AlignofExpr * node ) {
+                previsit( (const ParseNode *)node );
+                oneOfExprOrType( node );
+        }
+
         void previsit( const StructInstType * node ) {
                 previsit( (const Node *)node );
@@ -181 +200 @@
 /// referring to is in scope by the structural rules of code.
 // Any escapes marked with a bug should be removed once the bug is fixed.
+// This is a separate pass because of it changes the visit pattern and
+// must always be run on the entire translation unit.
 struct InScopeCore : public ast::WithShortCircuiting {
         ScopedSet<DeclWithType const *> typedDecls;

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
 

src/GenPoly/GenPoly.cc

@@ -48 +48 @@
                 }
 
-                bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const ast::TypeSubstitution * env) {
-                        for (auto &param : params) {
-                                auto paramType = param.strict_as<ast::TypeExpr>();
-                                if (isPolyType(paramType->type, env)) return true;
+                bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const ast::TypeSubstitution * env ) {
+                        for ( auto &param : params ) {
+                                auto paramType = param.as<ast::TypeExpr>();
+                                assertf( paramType, "Aggregate parameters should be type expressions" );
+                                if ( isPolyType( paramType->type, env ) ) return true;
                         }
                         return false;
@@ -62 +63 @@
                                 assertf(paramType, "Aggregate parameters should be type expressions");
                                 if ( isPolyType( paramType->get_type(), tyVars, env ) ) return true;
+                        }
+                        return false;
+                }
+
+                bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const TypeVarMap & typeVars, const ast::TypeSubstitution * env ) {
+                        for ( auto & param : params ) {
+                                auto paramType = param.as<ast::TypeExpr>();
+                                assertf( paramType, "Aggregate parameters should be type expressions" );
+                                if ( isPolyType( paramType->type, typeVars, env ) ) return true;
                         }
                         return false;
@@ -185 +195 @@
         }
 
-        const ast::Type * isPolyType(const ast::Type * type, const TyVarMap & tyVars, const ast::TypeSubstitution * env) {
-                type = replaceTypeInst( type, env );
-
-                if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
-                        if ( tyVars.contains( typeInst->typeString() ) ) return type;
-                } else if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
-                        return isPolyType( arrayType->base, env );
-                } else if ( auto structType = dynamic_cast< const ast::StructInstType* >( type ) ) {
-                        if ( hasPolyParams( structType->params, env ) ) return type;
-                } else if ( auto unionType = dynamic_cast< const ast::UnionInstType* >( type ) ) {
-                        if ( hasPolyParams( unionType->params, env ) ) return type;
-                }
-                return nullptr;
-        }
-
 const ast::Type * isPolyType( const ast::Type * type,
                 const TypeVarMap & typeVars, const ast::TypeSubstitution * subst ) {
@@ -207 +202 @@
                 if ( typeVars.contains( *inst ) ) return type;
         } else if ( auto array = dynamic_cast< const ast::ArrayType * >( type ) ) {
-                return isPolyType( array->base, subst );
+                return isPolyType( array->base, typeVars, subst );
         } else if ( auto sue = dynamic_cast< const ast::StructInstType * >( type ) ) {
-                if ( hasPolyParams( sue->params, subst ) ) return type;
+                if ( hasPolyParams( sue->params, typeVars, subst ) ) return type;
         } else if ( auto sue = dynamic_cast< const ast::UnionInstType * >( type ) ) {
-                if ( hasPolyParams( sue->params, subst ) ) return type;
+                if ( hasPolyParams( sue->params, typeVars, subst ) ) return type;
         }
         return nullptr;