Changeset 400b8be for src/ResolvExpr

Timestamp:

Mar 28, 2022, 10:41:45 AM (3 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, ast-experimental, enum, master, pthread-emulation, qualifiedEnum

Children:

8e819a9

Parents:

f5bace8

Message:

Added StmtClause? and converted the existing nodes that should be clauses.

File:

• src/ResolvExpr/Resolver.cc (modified) (4 diffs)

src/ResolvExpr/Resolver.cc ¶

@@ -1281 +1281 @@
                 const ast::ForStmt *         previsit( const ast::ForStmt * );
                 const ast::SwitchStmt *      previsit( const ast::SwitchStmt * );
-                const ast::CaseStmt *        previsit( const ast::CaseStmt * );
+                const ast::CaseClause *      previsit( const ast::CaseClause * );
                 const ast::BranchStmt *      previsit( const ast::BranchStmt * );
                 const ast::ReturnStmt *      previsit( const ast::ReturnStmt * );
                 const ast::ThrowStmt *       previsit( const ast::ThrowStmt * );
-                const ast::CatchStmt *       previsit( const ast::CatchStmt * );
-                const ast::CatchStmt *       postvisit( const ast::CatchStmt * );
+                const ast::CatchClause *     previsit( const ast::CatchClause * );
+                const ast::CatchClause *     postvisit( const ast::CatchClause * );
                 const ast::WaitForStmt *     previsit( const ast::WaitForStmt * );
                 const ast::WithStmt *        previsit( const ast::WithStmt * );
@@ -1615 +1615 @@
         }
 
-        const ast::CaseStmt * Resolver_new::previsit( const ast::CaseStmt * caseStmt ) {
+        const ast::CaseClause * Resolver_new::previsit( const ast::CaseClause * caseStmt ) {
                 if ( caseStmt->cond ) {
                         std::deque< ast::InitAlternative > initAlts = currentObject.getOptions();
@@ -1631 +1631 @@
                         }
 
-                        caseStmt = ast::mutate_field( caseStmt, &ast::CaseStmt::cond, newExpr );
+                        caseStmt = ast::mutate_field( caseStmt, &ast::CaseClause::cond, newExpr );
                 }
                 return caseStmt;
@@ -1674 +1674 @@
         }
 
-        const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
+        const ast::CatchClause * Resolver_new::previsit( const ast::CatchClause * catchClause ) {
                 // Until we are very sure this invarent (ifs that move between passes have then)
                 // holds, check it. This allows a check for when to decode the mangling.
-                if ( auto ifStmt = catchStmt->body.as<ast::IfStmt>() ) {
+                if ( auto ifStmt = catchClause->body.as<ast::IfStmt>() ) {
                         assert( ifStmt->then );
                 }
                 // Encode the catchStmt so the condition can see the declaration.
-                if ( catchStmt->cond ) {
-                        ast::CatchStmt * stmt = mutate( catchStmt );
-                        stmt->body = new ast::IfStmt( stmt->location, stmt->cond, nullptr, stmt->body );
-                        stmt->cond = nullptr;
-                        return stmt;
-                }
-                return catchStmt;
-        }
-
-        const ast::CatchStmt * Resolver_new::postvisit( const ast::CatchStmt * catchStmt ) {
+                if ( catchClause->cond ) {
+                        ast::CatchClause * clause = mutate( catchClause );
+                        clause->body = new ast::IfStmt( clause->location, clause->cond, nullptr, clause->body );
+                        clause->cond = nullptr;
+                        return clause;
+                }
+                return catchClause;
+        }
+
+        const ast::CatchClause * Resolver_new::postvisit( const ast::CatchClause * catchClause ) {
                 // Decode the catchStmt so everything is stored properly.
-                const ast::IfStmt * ifStmt = catchStmt->body.as<ast::IfStmt>();
+                const ast::IfStmt * ifStmt = catchClause->body.as<ast::IfStmt>();
                 if ( nullptr != ifStmt && nullptr == ifStmt->then ) {
                         assert( ifStmt->cond );
                         assert( ifStmt->else_ );
-                        ast::CatchStmt * stmt = ast::mutate( catchStmt );
-                        stmt->cond = ifStmt->cond;
-                        stmt->body = ifStmt->else_;
+                        ast::CatchClause * clause = ast::mutate( catchClause );
+                        clause->cond = ifStmt->cond;
+                        clause->body = ifStmt->else_;
                         // ifStmt should be implicately deleted here.
-                        return stmt;
-                }
-                return catchStmt;
+                        return clause;
+                }
+                return catchClause;
         }