Index: src/AST/Convert.cpp
===================================================================
--- src/AST/Convert.cpp	(revision f5bace8ecd312e656098f5267daf64c5b419bcb4)
+++ src/AST/Convert.cpp	(revision 400b8bec42ab40f3a00bc24c1485bc941ead2174)
@@ -353,4 +353,9 @@
 	}
 
+	void clausePostamble( Statement * stmt, const ast::StmtClause * node ) {
+		stmt->location = node->location;
+		this->node = stmt;
+	}
+
 	const ast::CompoundStmt * visit( const ast::CompoundStmt * node ) override final {
 		if ( inCache( node ) ) return nullptr;
@@ -401,10 +406,10 @@
 		auto stmt = new SwitchStmt(
 			get<Expression>().accept1( node->cond ),
-			get<Statement>().acceptL( node->stmts )
+			get<Statement>().acceptL( node->cases )
 		);
 		return stmtPostamble( stmt, node );
 	}
 
-	const ast::Stmt * visit( const ast::CaseStmt * node ) override final {
+	const ast::CaseClause * visit( const ast::CaseClause * node ) override final {
 		if ( inCache( node ) ) return nullptr;
 		auto stmt = new CaseStmt(
@@ -413,5 +418,6 @@
 			node->isDefault()
 		);
-		return stmtPostamble( stmt, node );
+		clausePostamble( stmt, node );
+		return nullptr;
 	}
 
@@ -509,5 +515,5 @@
 	}
 
-	const ast::Stmt * visit( const ast::CatchStmt * node ) override final {
+	const ast::CatchClause * visit( const ast::CatchClause * node ) override final {
 		if ( inCache( node ) ) return nullptr;
 		CatchStmt::Kind kind;
@@ -520,5 +526,5 @@
 			break;
 		default:
-			assertf(false, "Invalid ast::CatchStmt::Kind: %d\n", node->kind);
+			assertf(false, "Invalid ast::ExceptionKind: %d\n", node->kind);
 		}
 		auto stmt = new CatchStmt(
@@ -528,11 +534,11 @@
 			get<Statement>().accept1( node->body )
 		);
-		return stmtPostamble( stmt, node );
-	}
-
-	const ast::Stmt * visit( const ast::FinallyStmt * node ) override final {
+		return clausePostamble( stmt, node ), nullptr;
+	}
+
+	const ast::FinallyClause * visit( const ast::FinallyClause * node ) override final {
 		if ( inCache( node ) ) return nullptr;
 		auto stmt = new FinallyStmt( get<CompoundStmt>().accept1( node->body ) );
-		return stmtPostamble( stmt, node );
+		return clausePostamble( stmt, node ), nullptr;
 	}
 
@@ -1884,5 +1890,5 @@
 			old->location,
 			GET_ACCEPT_1(condition, Expr),
-			GET_ACCEPT_V(statements, Stmt),
+			GET_ACCEPT_V(statements, CaseClause),
 			GET_LABELS_V(old->labels)
 		);
@@ -1892,10 +1898,11 @@
 	virtual void visit( const CaseStmt * old ) override final {
 		if ( inCache( old ) ) return;
-		this->node = new ast::CaseStmt(
+		this->node = new ast::CaseClause(
 			old->location,
 			GET_ACCEPT_1(condition, Expr),
-			GET_ACCEPT_V(stmts, Stmt),
-			GET_LABELS_V(old->labels)
-		);
+			GET_ACCEPT_V(stmts, Stmt)
+		);
+		auto labels = GET_LABELS_V(old->labels);
+		assertf(labels.empty(), "Labels found on CaseStmt.");
 		cache.emplace( old, this->node );
 	}
@@ -2005,6 +2012,6 @@
 			old->location,
 			GET_ACCEPT_1(block, CompoundStmt),
-			GET_ACCEPT_V(handlers, CatchStmt),
-			GET_ACCEPT_1(finallyBlock, FinallyStmt),
+			GET_ACCEPT_V(handlers, CatchClause),
+			GET_ACCEPT_1(finallyBlock, FinallyClause),
 			GET_LABELS_V(old->labels)
 		);
@@ -2026,12 +2033,13 @@
 		}
 
-		this->node = new ast::CatchStmt(
+		this->node = new ast::CatchClause(
 			old->location,
 			kind,
 			GET_ACCEPT_1(decl, Decl),
 			GET_ACCEPT_1(cond, Expr),
-			GET_ACCEPT_1(body, Stmt),
-			GET_LABELS_V(old->labels)
-		);
+			GET_ACCEPT_1(body, Stmt)
+		);
+		auto labels = GET_LABELS_V(old->labels);
+		assertf(labels.empty(), "Labels found on CatchStmt.");
 		cache.emplace( old, this->node );
 	}
@@ -2039,9 +2047,10 @@
 	virtual void visit( const FinallyStmt * old ) override final {
 		if ( inCache( old ) ) return;
-		this->node = new ast::FinallyStmt(
-			old->location,
-			GET_ACCEPT_1(block, CompoundStmt),
-			GET_LABELS_V(old->labels)
-		);
+		this->node = new ast::FinallyClause(
+			old->location,
+			GET_ACCEPT_1(block, CompoundStmt)
+		);
+		auto labels = GET_LABELS_V(old->labels);
+		assertf(labels.empty(), "Labels found on FinallyStmt.");
 		cache.emplace( old, this->node );
 	}
Index: src/AST/Fwd.hpp
===================================================================
--- src/AST/Fwd.hpp	(revision f5bace8ecd312e656098f5267daf64c5b419bcb4)
+++ src/AST/Fwd.hpp	(revision 400b8bec42ab40f3a00bc24c1485bc941ead2174)
@@ -47,11 +47,11 @@
 class ForStmt;
 class SwitchStmt;
-class CaseStmt;
+class CaseClause;
 class BranchStmt;
 class ReturnStmt;
 class ThrowStmt;
 class TryStmt;
-class CatchStmt;
-class FinallyStmt;
+class CatchClause;
+class FinallyClause;
 class SuspendStmt;
 class WaitForStmt;
Index: src/AST/Node.cpp
===================================================================
--- src/AST/Node.cpp	(revision f5bace8ecd312e656098f5267daf64c5b419bcb4)
+++ src/AST/Node.cpp	(revision 400b8bec42ab40f3a00bc24c1485bc941ead2174)
@@ -160,6 +160,6 @@
 template class ast::ptr_base< ast::SwitchStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::SwitchStmt, ast::Node::ref_type::strong >;
-template class ast::ptr_base< ast::CaseStmt, ast::Node::ref_type::weak >;
-template class ast::ptr_base< ast::CaseStmt, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::CaseClause, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::CaseClause, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::BranchStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::BranchStmt, ast::Node::ref_type::strong >;
@@ -170,8 +170,8 @@
 template class ast::ptr_base< ast::TryStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::TryStmt, ast::Node::ref_type::strong >;
-template class ast::ptr_base< ast::CatchStmt, ast::Node::ref_type::weak >;
-template class ast::ptr_base< ast::CatchStmt, ast::Node::ref_type::strong >;
-template class ast::ptr_base< ast::FinallyStmt, ast::Node::ref_type::weak >;
-template class ast::ptr_base< ast::FinallyStmt, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::CatchClause, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::CatchClause, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::FinallyClause, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::FinallyClause, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::strong >;
Index: src/AST/Pass.hpp
===================================================================
--- src/AST/Pass.hpp	(revision f5bace8ecd312e656098f5267daf64c5b419bcb4)
+++ src/AST/Pass.hpp	(revision 400b8bec42ab40f3a00bc24c1485bc941ead2174)
@@ -149,11 +149,11 @@
 	const ast::Stmt *             visit( const ast::ForStmt              * ) override final;
 	const ast::Stmt *             visit( const ast::SwitchStmt           * ) override final;
-	const ast::Stmt *             visit( const ast::CaseStmt             * ) override final;
+	const ast::CaseClause *       visit( const ast::CaseClause           * ) override final;
 	const ast::Stmt *             visit( const ast::BranchStmt           * ) override final;
 	const ast::Stmt *             visit( const ast::ReturnStmt           * ) override final;
 	const ast::Stmt *             visit( const ast::ThrowStmt            * ) override final;
 	const ast::Stmt *             visit( const ast::TryStmt              * ) override final;
-	const ast::Stmt *             visit( const ast::CatchStmt            * ) override final;
-	const ast::Stmt *             visit( const ast::FinallyStmt          * ) override final;
+	const ast::CatchClause *      visit( const ast::CatchClause          * ) override final;
+	const ast::FinallyClause *    visit( const ast::FinallyClause        * ) override final;
 	const ast::Stmt *             visit( const ast::SuspendStmt          * ) override final;
 	const ast::Stmt *             visit( const ast::WaitForStmt          * ) override final;
Index: src/AST/Pass.impl.hpp
===================================================================
--- src/AST/Pass.impl.hpp	(revision f5bace8ecd312e656098f5267daf64c5b419bcb4)
+++ src/AST/Pass.impl.hpp	(revision 400b8bec42ab40f3a00bc24c1485bc941ead2174)
@@ -893,5 +893,5 @@
 	if ( __visit_children() ) {
 		maybe_accept( node, &SwitchStmt::cond  );
-		maybe_accept( node, &SwitchStmt::stmts );
+		maybe_accept( node, &SwitchStmt::cases );
 	}
 
@@ -900,15 +900,15 @@
 
 //--------------------------------------------------------------------------
-// CaseStmt
-template< typename core_t >
-const ast::Stmt * ast::Pass< core_t >::visit( const ast::CaseStmt * node ) {
-	VISIT_START( node );
-
-	if ( __visit_children() ) {
-		maybe_accept( node, &CaseStmt::cond  );
-		maybe_accept( node, &CaseStmt::stmts );
-	}
-
-	VISIT_END( Stmt, node );
+// CaseClause
+template< typename core_t >
+const ast::CaseClause * ast::Pass< core_t >::visit( const ast::CaseClause * node ) {
+	VISIT_START( node );
+
+	if ( __visit_children() ) {
+		maybe_accept( node, &CaseClause::cond  );
+		maybe_accept( node, &CaseClause::stmts );
+	}
+
+	VISIT_END( CaseClause, node );
 }
 
@@ -964,7 +964,7 @@
 
 //--------------------------------------------------------------------------
-// CatchStmt
-template< typename core_t >
-const ast::Stmt * ast::Pass< core_t >::visit( const ast::CatchStmt * node ) {
+// CatchClause
+template< typename core_t >
+const ast::CatchClause * ast::Pass< core_t >::visit( const ast::CatchClause * node ) {
 	VISIT_START( node );
 
@@ -972,23 +972,23 @@
 		// catch statements introduce a level of scope (for the caught exception)
 		guard_symtab guard { *this };
-		maybe_accept( node, &CatchStmt::decl );
-		maybe_accept( node, &CatchStmt::cond );
-		maybe_accept_as_compound( node, &CatchStmt::body );
-	}
-
-	VISIT_END( Stmt, node );
-}
-
-//--------------------------------------------------------------------------
-// FinallyStmt
-template< typename core_t >
-const ast::Stmt * ast::Pass< core_t >::visit( const ast::FinallyStmt * node ) {
-	VISIT_START( node );
-
-	if ( __visit_children() ) {
-		maybe_accept( node, &FinallyStmt::body );
-	}
-
-	VISIT_END( Stmt, node );
+		maybe_accept( node, &CatchClause::decl );
+		maybe_accept( node, &CatchClause::cond );
+		maybe_accept_as_compound( node, &CatchClause::body );
+	}
+
+	VISIT_END( CatchClause, node );
+}
+
+//--------------------------------------------------------------------------
+// FinallyClause
+template< typename core_t >
+const ast::FinallyClause * ast::Pass< core_t >::visit( const ast::FinallyClause * node ) {
+	VISIT_START( node );
+
+	if ( __visit_children() ) {
+		maybe_accept( node, &FinallyClause::body );
+	}
+
+	VISIT_END( FinallyClause, node );
 }
 
Index: src/AST/Print.cpp
===================================================================
--- src/AST/Print.cpp	(revision f5bace8ecd312e656098f5267daf64c5b419bcb4)
+++ src/AST/Print.cpp	(revision 400b8bec42ab40f3a00bc24c1485bc941ead2174)
@@ -589,5 +589,5 @@
 
 		++indent;
-		for ( const ast::Stmt * stmt : node->stmts ) {
+		for ( const ast::CaseClause * stmt : node->cases ) {
 			stmt->accept( *this );
 		}
@@ -597,5 +597,5 @@
 	}
 
-	virtual const ast::Stmt * visit( const ast::CaseStmt * node ) override final {
+	virtual const ast::CaseClause * visit( const ast::CaseClause * node ) override final {
 		if ( node->isDefault() ) {
 			os << indent << "Default ";
@@ -679,5 +679,5 @@
 
 		os << indent-1 << "... and handlers:" << endl;
-		for ( const ast::CatchStmt * stmt : node->handlers ) {
+		for ( const ast::CatchClause * stmt : node->handlers ) {
 			os << indent;
 			stmt->accept( *this );
@@ -693,5 +693,5 @@
 	}
 
-	virtual const ast::Stmt * visit( const ast::CatchStmt * node ) override final {
+	virtual const ast::CatchClause * visit( const ast::CatchClause * node ) override final {
 		os << "Catch ";
 		switch ( node->kind ) {
@@ -718,5 +718,5 @@
 	}
 
-	virtual const ast::Stmt * visit( const ast::FinallyStmt * node ) override final {
+	virtual const ast::FinallyClause * visit( const ast::FinallyClause * node ) override final {
 		os << "Finally Statement" << endl;
 		os << indent << "... with block:" << endl;
Index: src/AST/Stmt.hpp
===================================================================
--- src/AST/Stmt.hpp	(revision f5bace8ecd312e656098f5267daf64c5b419bcb4)
+++ src/AST/Stmt.hpp	(revision 400b8bec42ab40f3a00bc24c1485bc941ead2174)
@@ -9,7 +9,7 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed May  8 13:00:00 2019
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb  2 20:06:41 2022
-// Update Count     : 34
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Mar 28  9:50:00 2022
+// Update Count     : 35
 //
 
@@ -47,4 +47,20 @@
   private:
 	Stmt * clone() const override = 0;
+	MUTATE_FRIEND
+};
+
+// Base statement component node (only serves to group them).
+class StmtClause : public ParseNode {
+  public:
+	// This is for non-statements that still belong with the statements,
+	// but are not statements, usually some sort of clause. Often these can
+	// (and should) be folded into the approprate parent node, but if they
+	// cannot be, they are sub-types of this type, for organization.
+
+    StmtClause( const CodeLocation & loc )
+		: ParseNode(loc) {}
+
+  private:
+	StmtClause * clone() const override = 0;
 	MUTATE_FRIEND
 };
@@ -158,32 +174,32 @@
   public:
 	ptr<Expr> cond;
+	std::vector<ptr<CaseClause>> cases;
+
+	SwitchStmt( const CodeLocation & loc, const Expr * cond,
+				const std::vector<ptr<CaseClause>> && cases,
+				const std::vector<Label> && labels = {} )
+		: Stmt(loc, std::move(labels)), cond(cond), cases(std::move(cases)) {}
+
+	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+	SwitchStmt * clone() const override { return new SwitchStmt{ *this }; }
+	MUTATE_FRIEND
+};
+
+// Case label: case ...: or default:
+class CaseClause final : public StmtClause {
+  public:
+	// Null for the default label.
+	ptr<Expr> cond;
 	std::vector<ptr<Stmt>> stmts;
 
-	SwitchStmt( const CodeLocation & loc, const Expr * cond, const std::vector<ptr<Stmt>> && stmts,
-				const std::vector<Label> && labels = {} )
-		: Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
-
-	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-  private:
-	SwitchStmt * clone() const override { return new SwitchStmt{ *this }; }
-	MUTATE_FRIEND
-};
-
-// Case label: case ...: or default:
-class CaseStmt final : public Stmt {
-  public:
-	// Null for the default label.
-	ptr<Expr> cond;
-	std::vector<ptr<Stmt>> stmts;
-
-	CaseStmt( const CodeLocation & loc, const Expr * cond, const std::vector<ptr<Stmt>> && stmts,
-			  const std::vector<Label> && labels = {} )
-		: Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
+	CaseClause( const CodeLocation & loc, const Expr * cond, const std::vector<ptr<Stmt>> && stmts )
+		: StmtClause(loc), cond(cond), stmts(std::move(stmts)) {}
 
 	bool isDefault() const { return !cond; }
 
-	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-  private:
-	CaseStmt * clone() const override { return new CaseStmt{ *this }; }
+	const CaseClause * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+	CaseClause * clone() const override { return new CaseClause{ *this }; }
 	MUTATE_FRIEND
 };
@@ -298,9 +314,9 @@
   public:
 	ptr<CompoundStmt> body;
-	std::vector<ptr<CatchStmt>> handlers;
-	ptr<FinallyStmt> finally;
+	std::vector<ptr<CatchClause>> handlers;
+	ptr<FinallyClause> finally;
 
 	TryStmt( const CodeLocation & loc, const CompoundStmt * body,
-			 const std::vector<ptr<CatchStmt>> && handlers, const FinallyStmt * finally,
+			 const std::vector<ptr<CatchClause>> && handlers, const FinallyClause * finally,
 			 const std::vector<Label> && labels = {} )
 		: Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}
@@ -313,5 +329,5 @@
 
 // Catch clause of try statement
-class CatchStmt final : public Stmt {
+class CatchClause final : public StmtClause {
   public:
 	ptr<Decl> decl;
@@ -320,26 +336,25 @@
 	ExceptionKind kind;
 
-	CatchStmt( const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
-			   const Stmt * body, const std::vector<Label> && labels = {} )
-		: Stmt(loc, std::move(labels)), decl(decl), cond(cond), body(body), kind(kind) {}
-
-	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-  private:
-	CatchStmt * clone() const override { return new CatchStmt{ *this }; }
+	CatchClause( const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
+			   const Stmt * body )
+		: StmtClause(loc), decl(decl), cond(cond), body(body), kind(kind) {}
+
+	const CatchClause * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+	CatchClause * clone() const override { return new CatchClause{ *this }; }
 	MUTATE_FRIEND
 };
 
 // Finally clause of try statement
-class FinallyStmt final : public Stmt {
+class FinallyClause final : public StmtClause {
   public:
 	ptr<CompoundStmt> body;
 
-	FinallyStmt( const CodeLocation & loc, const CompoundStmt * body,
-				 std::vector<Label> && labels = {} )
-		: Stmt(loc, std::move(labels)), body(body) {}
-
-	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-  private:
-	FinallyStmt * clone() const override { return new FinallyStmt{ *this }; }
+	FinallyClause( const CodeLocation & loc, const CompoundStmt * body )
+		: StmtClause(loc), body(body) {}
+
+	const FinallyClause * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+	FinallyClause * clone() const override { return new FinallyClause{ *this }; }
 	MUTATE_FRIEND
 };
Index: src/AST/Visitor.hpp
===================================================================
--- src/AST/Visitor.hpp	(revision f5bace8ecd312e656098f5267daf64c5b419bcb4)
+++ src/AST/Visitor.hpp	(revision 400b8bec42ab40f3a00bc24c1485bc941ead2174)
@@ -41,11 +41,11 @@
     virtual const ast::Stmt *             visit( const ast::ForStmt              * ) = 0;
     virtual const ast::Stmt *             visit( const ast::SwitchStmt           * ) = 0;
-    virtual const ast::Stmt *             visit( const ast::CaseStmt             * ) = 0;
+    virtual const ast::CaseClause *       visit( const ast::CaseClause           * ) = 0;
     virtual const ast::Stmt *             visit( const ast::BranchStmt           * ) = 0;
     virtual const ast::Stmt *             visit( const ast::ReturnStmt           * ) = 0;
     virtual const ast::Stmt *             visit( const ast::ThrowStmt            * ) = 0;
     virtual const ast::Stmt *             visit( const ast::TryStmt              * ) = 0;
-    virtual const ast::Stmt *             visit( const ast::CatchStmt            * ) = 0;
-    virtual const ast::Stmt *             visit( const ast::FinallyStmt          * ) = 0;
+    virtual const ast::CatchClause *      visit( const ast::CatchClause          * ) = 0;
+    virtual const ast::FinallyClause *    visit( const ast::FinallyClause        * ) = 0;
     virtual const ast::Stmt *             visit( const ast::SuspendStmt          * ) = 0;
     virtual const ast::Stmt *             visit( const ast::WaitForStmt          * ) = 0;
Index: src/Common/CodeLocationTools.cpp
===================================================================
--- src/Common/CodeLocationTools.cpp	(revision f5bace8ecd312e656098f5267daf64c5b419bcb4)
+++ src/Common/CodeLocationTools.cpp	(revision 400b8bec42ab40f3a00bc24c1485bc941ead2174)
@@ -112,11 +112,11 @@
     macro(ForStmt, Stmt) \
     macro(SwitchStmt, Stmt) \
-    macro(CaseStmt, Stmt) \
+    macro(CaseClause, CaseClause) \
     macro(BranchStmt, Stmt) \
     macro(ReturnStmt, Stmt) \
     macro(ThrowStmt, Stmt) \
     macro(TryStmt, Stmt) \
-    macro(CatchStmt, Stmt) \
-    macro(FinallyStmt, Stmt) \
+    macro(CatchClause, CatchClause) \
+    macro(FinallyClause, FinallyClause) \
     macro(SuspendStmt, Stmt) \
     macro(WaitForStmt, Stmt) \
Index: src/Concurrency/KeywordsNew.cpp
===================================================================
--- src/Concurrency/KeywordsNew.cpp	(revision f5bace8ecd312e656098f5267daf64c5b419bcb4)
+++ src/Concurrency/KeywordsNew.cpp	(revision 400b8bec42ab40f3a00bc24c1485bc941ead2174)
@@ -1333,9 +1333,9 @@
 
 		// construct the current try
-		currentTry = new ast::TryStmt( 
-			location, 
-			currTryBody, 
-			{}, 
-			new ast::FinallyStmt( location, currFinallyBody )
+		currentTry = new ast::TryStmt(
+			location,
+			currTryBody,
+			{},
+			new ast::FinallyClause( location, currFinallyBody )
 		);
 		if ( i == 0 ) outerTry = currentTry;
@@ -1351,5 +1351,5 @@
 		lastBody->push_back( body );
 		newBody->push_front( outerTry );
-	}	
+	}
 
 	// monitor_guard_t __guard = { __monitors, # };
Index: src/ControlStruct/ExceptTranslateNew.cpp
===================================================================
--- src/ControlStruct/ExceptTranslateNew.cpp	(revision f5bace8ecd312e656098f5267daf64c5b419bcb4)
+++ src/ControlStruct/ExceptTranslateNew.cpp	(revision 400b8bec42ab40f3a00bc24c1485bc941ead2174)
@@ -26,5 +26,5 @@
 namespace {
 
-	typedef std::list<ast::CatchStmt*> CatchList;
+	typedef std::list<ast::CatchClause*> CatchList;
 
 	void appendDeclStmt( ast::CompoundStmt * block, ast::DeclWithType * item ) {
@@ -45,5 +45,5 @@
 	{}
 
-	void previsit( const ast::CatchStmt * stmt );
+	void previsit( const ast::CatchClause * stmt );
 	const ast::Stmt * postvisit( const ast::ThrowStmt * stmt );
 };
@@ -88,5 +88,5 @@
 }
 
-void TranslateThrowsCore::previsit( const ast::CatchStmt * stmt ) {
+void TranslateThrowsCore::previsit( const ast::CatchClause * stmt ) {
 	// Validate the statement's form.
 	const ast::ObjectDecl * decl = stmt->decl.as<ast::ObjectDecl>();
@@ -147,5 +147,5 @@
 	ast::FunctionDecl * create_terminate_catch( CatchList &handlers );
 	ast::CompoundStmt * create_single_matcher(
-		const ast::DeclWithType * except_obj, ast::CatchStmt * modded_handler );
+		const ast::DeclWithType * except_obj, ast::CatchClause * modded_handler );
 	ast::FunctionDecl * create_terminate_match( CatchList &handlers );
 	ast::CompoundStmt * create_terminate_caller( CodeLocation loc, ast::FunctionDecl * try_wrapper,
@@ -338,5 +338,5 @@
 ast::FunctionDecl * TryMutatorCore::create_terminate_catch(
 		CatchList &handlers ) {
-	std::vector<ast::ptr<ast::Stmt>> handler_wrappers;
+	std::vector<ast::ptr<ast::CaseClause>> handler_wrappers;
 
 	assert (!handlers.empty());
@@ -352,5 +352,5 @@
 	for ( ; it != handlers.end() ; ++it ) {
 		++index;
-		ast::CatchStmt * handler = *it;
+		ast::CatchClause * handler = *it;
 		const CodeLocation loc = handler->location;
 
@@ -390,5 +390,5 @@
 		// handler->body = nullptr;
 
-		handler_wrappers.push_back( new ast::CaseStmt(loc,
+		handler_wrappers.push_back( new ast::CaseClause(loc,
 			ast::ConstantExpr::from_int(loc, index) ,
 			{ block, new ast::ReturnStmt( loc, nullptr ) }
@@ -410,5 +410,5 @@
 // except_obj is referenced, modded_handler will be freed.
 ast::CompoundStmt * TryMutatorCore::create_single_matcher(
-		const ast::DeclWithType * except_obj, ast::CatchStmt * modded_handler ) {
+		const ast::DeclWithType * except_obj, ast::CatchClause * modded_handler ) {
 	// {
 	//     `modded_handler.decl`
@@ -465,5 +465,5 @@
 	for ( it = handlers.begin() ; it != handlers.end() ; ++it ) {
 		++index;
-		ast::CatchStmt * handler = *it;
+		ast::CatchClause * handler = *it;
 
 		// Body should have been taken by create_terminate_catch.
@@ -520,5 +520,5 @@
 	CatchList::iterator it;
 	for ( it = handlers.begin() ; it != handlers.end() ; ++it ) {
-		ast::CatchStmt * handler = *it;
+		ast::CatchClause * handler = *it;
 		const CodeLocation loc = handler->location;
 		// Modifiy body.
@@ -587,5 +587,5 @@
 		ast::TryStmt * tryStmt ) {
 	// void finally() { `finally->block` }
-	const ast::FinallyStmt * finally = tryStmt->finally;
+	const ast::FinallyClause * finally = tryStmt->finally;
 	const ast::CompoundStmt * body = finally->body;
 
Index: src/ControlStruct/LabelGeneratorNew.cpp
===================================================================
--- src/ControlStruct/LabelGeneratorNew.cpp	(revision f5bace8ecd312e656098f5267daf64c5b419bcb4)
+++ src/ControlStruct/LabelGeneratorNew.cpp	(revision 400b8bec42ab40f3a00bc24c1485bc941ead2174)
@@ -5,11 +5,11 @@
 // file "LICENCE" distributed with Cforall.
 //
-// LabelGenerator.cc --
+// LabelGeneratorNew.cpp --
 //
 // Author           : Peter A. Buhr
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb  2 09:11:17 2022
-// Update Count     : 72
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Mar 28 10:03:00 2022
+// Update Count     : 73
 //
 
@@ -25,13 +25,26 @@
 namespace ControlStruct {
 
-Label newLabel( const string & suffix, const Stmt * stmt ) {
+enum { size = 128 };
+
+static int newLabelPre( char buf[size], const string & suffix ) {
 	static int current = 0;
 
-	assertf( stmt, "CFA internal error: parameter statement cannot be null pointer" );
-
-	enum { size = 128 };
-	char buf[size];										// space to build label
 	int len = snprintf( buf, size, "__L%d__%s", current++, suffix.c_str() );
 	assertf( len < size, "CFA Internal error: buffer overflow creating label" );
+	return len;
+}
+
+static Label newLabelPost( char buf[size], const CodeLocation & location ) {
+	Label ret_label( location, buf );
+	ret_label.attributes.push_back( new Attribute( "unused" ) );
+	return ret_label;
+}
+
+Label newLabel( const string & suffix, const Stmt * stmt ) {
+	// Buffer for string manipulation.
+	char buf[size];
+
+	assertf( stmt, "CFA internal error: parameter statement cannot be null pointer" );
+	int len = newLabelPre( buf, suffix );
 
 	// What does this do?
@@ -41,7 +54,13 @@
 	} // if
 
-	Label ret_label( stmt->location, buf );
-	ret_label.attributes.push_back( new Attribute( "unused" ) );
-	return ret_label;
+	return newLabelPost( buf, stmt->location );
+}
+
+Label newLabel( const string & suffix, const CodeLocation & location ) {
+	// Buffer for string manipulation.
+	char buf[size];
+
+	newLabelPre( buf, suffix );
+	return newLabelPost( buf, location );
 }
 
Index: src/ControlStruct/LabelGeneratorNew.hpp
===================================================================
--- src/ControlStruct/LabelGeneratorNew.hpp	(revision f5bace8ecd312e656098f5267daf64c5b419bcb4)
+++ src/ControlStruct/LabelGeneratorNew.hpp	(revision 400b8bec42ab40f3a00bc24c1485bc941ead2174)
@@ -9,7 +9,7 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan 31 18:03:09 2022
-// Update Count     : 27
+// Last Modified By : Andrew Beach
+// Last Modified On : Fir Mar 25 15:40:00 2022
+// Update Count     : 28
 //
 
@@ -18,13 +18,14 @@
 #include <string>										// for string
 
-class Statement;
+class CodeLocation;
 
 namespace ast {
+	class Label;
 	class Stmt;
-	class Label;
 } // namespace ast
 
 namespace ControlStruct {
 	ast::Label newLabel( const std::string &, const ast::Stmt * );
+	ast::Label newLabel( const std::string &, const CodeLocation & );
 } // namespace ControlStruct
 
Index: src/ControlStruct/MultiLevelExit.cpp
===================================================================
--- src/ControlStruct/MultiLevelExit.cpp	(revision f5bace8ecd312e656098f5267daf64c5b419bcb4)
+++ src/ControlStruct/MultiLevelExit.cpp	(revision 400b8bec42ab40f3a00bc24c1485bc941ead2174)
@@ -9,7 +9,7 @@
 // Author           : Andrew Beach
 // Created On       : Mon Nov  1 13:48:00 2021
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb  2 23:07:54 2022
-// Update Count     : 33
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Mar 28  9:42:00 2022
+// Update Count     : 34
 //
 
@@ -40,5 +40,5 @@
 
 	enum Kind {
-		ForStmtK, WhileDoStmtK, CompoundStmtK, IfStmtK, CaseStmtK, SwitchStmtK, TryStmtK
+		ForStmtK, WhileDoStmtK, CompoundStmtK, IfStmtK, CaseClauseK, SwitchStmtK, TryStmtK
 	} kind;
 
@@ -58,6 +58,6 @@
 	Entry( const IfStmt *stmt, Label breakExit ) :
 		stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( IfStmtK ) {}
-	Entry( const CaseStmt *stmt, Label fallExit ) :
-		stmt( stmt ), firstTarget( fallExit ), secondTarget(), kind( CaseStmtK ) {}
+	Entry( const CaseClause *, const CompoundStmt *stmt, Label fallExit ) :
+		stmt( stmt ), firstTarget( fallExit ), secondTarget(), kind( CaseClauseK ) {}
 	Entry( const SwitchStmt *stmt, Label breakExit, Label fallDefaultExit ) :
 		stmt( stmt ), firstTarget( breakExit ), secondTarget( fallDefaultExit ), kind( SwitchStmtK ) {}
@@ -66,18 +66,18 @@
 
 	bool isContTarget() const { return kind <= WhileDoStmtK; }
-	bool isBreakTarget() const { return kind != CaseStmtK; }
-	bool isFallTarget() const { return kind == CaseStmtK; }
+	bool isBreakTarget() const { return kind != CaseClauseK; }
+	bool isFallTarget() const { return kind == CaseClauseK; }
 	bool isFallDefaultTarget() const { return kind == SwitchStmtK; }
 
 	// These routines set a target as being "used" by a BranchStmt
 	Label useContExit() { assert( kind <= WhileDoStmtK ); return useTarget(secondTarget); }
-	Label useBreakExit() { assert( kind != CaseStmtK ); return useTarget(firstTarget); }
-	Label useFallExit() { assert( kind == CaseStmtK );  return useTarget(firstTarget); }
+	Label useBreakExit() { assert( kind != CaseClauseK ); return useTarget(firstTarget); }
+	Label useFallExit() { assert( kind == CaseClauseK );  return useTarget(firstTarget); }
 	Label useFallDefaultExit() { assert( kind == SwitchStmtK ); return useTarget(secondTarget); }
 
 	// These routines check if a specific label for a statement is used by a BranchStmt
 	bool isContUsed() const { assert( kind <= WhileDoStmtK ); return secondTarget.used; }
-	bool isBreakUsed() const { assert( kind != CaseStmtK ); return firstTarget.used; }
-	bool isFallUsed() const { assert( kind == CaseStmtK ); return firstTarget.used; }
+	bool isBreakUsed() const { assert( kind != CaseClauseK ); return firstTarget.used; }
+	bool isFallUsed() const { assert( kind == CaseClauseK ); return firstTarget.used; }
 	bool isFallDefaultUsed() const { assert( kind == SwitchStmtK ); return secondTarget.used; }
 	void seenDefault() { fallDefaultValid = false; }
@@ -115,5 +115,5 @@
 	void previsit( const ForStmt * );
 	const ForStmt * postvisit( const ForStmt * );
-	const CaseStmt * previsit( const CaseStmt * );
+	const CaseClause * previsit( const CaseClause * );
 	void previsit( const IfStmt * );
 	const IfStmt * postvisit( const IfStmt * );
@@ -123,5 +123,5 @@
 	void previsit( const TryStmt * );
 	void postvisit( const TryStmt * );
-	void previsit( const FinallyStmt * );
+	void previsit( const FinallyClause * );
 
 	const Stmt * mutateLoop( const Stmt * body, Entry& );
@@ -288,6 +288,5 @@
 		  auto switchStmt = strict_dynamic_cast< const SwitchStmt * >( targetEntry->stmt );
 		  bool foundDefault = false;
-		  for ( auto subStmt : switchStmt->stmts ) {
-			  const CaseStmt * caseStmt = subStmt.strict_as<CaseStmt>();
+		  for ( auto caseStmt : switchStmt->cases ) {
 			  if ( caseStmt->isDefault() ) {
 				  foundDefault = true;
@@ -365,5 +364,5 @@
 }
 
-const CaseStmt * MultiLevelExitCore::previsit( const CaseStmt * stmt ) {
+const CaseClause * MultiLevelExitCore::previsit( const CaseClause * stmt ) {
 	visit_children = false;
 
@@ -375,19 +374,21 @@
 
 	// The cond may not exist, but if it does update it now.
-	visitor->maybe_accept( stmt, &CaseStmt::cond );
+	visitor->maybe_accept( stmt, &CaseClause::cond );
 
 	// Just save the mutated node for simplicity.
-	CaseStmt * mutStmt = mutate( stmt );
-
-	Label fallLabel = newLabel( "fallThrough", stmt );
+	CaseClause * mutStmt = mutate( stmt );
+
+	Label fallLabel = newLabel( "fallThrough", stmt->location );
 	if ( ! mutStmt->stmts.empty() ) {
+		// These should already be in a block.
+		auto first = mutStmt->stmts.front().get_and_mutate();
+		auto block = strict_dynamic_cast<CompoundStmt *>( first );
+
 		// Ensure that the stack isn't corrupted by exceptions in fixBlock.
 		auto guard = makeFuncGuard(
-			[&](){ enclosing_control_structures.emplace_back( mutStmt, fallLabel ); },
+			[&](){ enclosing_control_structures.emplace_back( mutStmt, block, fallLabel ); },
 			[this](){ enclosing_control_structures.pop_back(); }
 			);
 
-		// These should already be in a block.
-		auto block = mutate( mutStmt->stmts.front().strict_as<CompoundStmt>() );
 		block->kids = fixBlock( block->kids, true );
 
@@ -396,5 +397,5 @@
 		Entry & entry = enclosing_control_structures.back();
 		if ( entry.isFallUsed() ) {
-			mutStmt->stmts.push_back( labelledNullStmt( mutStmt->location, entry.useFallExit() ) );
+			mutStmt->stmts.push_back( labelledNullStmt( block->location, entry.useFallExit() ) );
 		}
 	}
@@ -433,15 +434,14 @@
 }
 
-bool isDefaultCase( const ptr<Stmt> & stmt ) {
-	const CaseStmt * caseStmt = stmt.strict_as<CaseStmt>();
-	return caseStmt->isDefault();
+static bool isDefaultCase( const ptr<CaseClause> & caseClause ) {
+	return caseClause->isDefault();
 }
 
 void MultiLevelExitCore::previsit( const SwitchStmt * stmt ) {
 	Label label = newLabel( "switchBreak", stmt );
-	auto it = find_if( stmt->stmts.rbegin(), stmt->stmts.rend(), isDefaultCase );
-
-	const CaseStmt * defaultCase = it != stmt->stmts.rend() ? (it)->strict_as<CaseStmt>() : nullptr;
-	Label defaultLabel = defaultCase ? newLabel( "fallThroughDefault", defaultCase ) : Label( stmt->location, "" );
+	auto it = find_if( stmt->cases.rbegin(), stmt->cases.rend(), isDefaultCase );
+
+	const CaseClause * defaultCase = it != stmt->cases.rend() ? (*it) : nullptr;
+	Label defaultLabel = defaultCase ? newLabel( "fallThroughDefault", defaultCase->location ) : Label( stmt->location, "" );
 	enclosing_control_structures.emplace_back( stmt, label, defaultLabel );
 	GuardAction( [this]() { enclosing_control_structures.pop_back(); } );
@@ -449,6 +449,5 @@
 	// Collect valid labels for fallthrough. It starts with all labels at this level, then remove as each is seen during
 	// traversal.
-	for ( const Stmt * stmt : stmt->stmts ) {
-		auto * caseStmt = strict_dynamic_cast< const CaseStmt * >( stmt );
+	for ( const CaseClause * caseStmt : stmt->cases ) {
 		if ( caseStmt->stmts.empty() ) continue;
 		auto block = caseStmt->stmts.front().strict_as<CompoundStmt>();
@@ -471,11 +470,11 @@
 		// exit label and break to the last case, create a default case if no cases.
 		SwitchStmt * mutStmt = mutate( stmt );
-		if ( mutStmt->stmts.empty() ) {
-			mutStmt->stmts.push_back( new CaseStmt( mutStmt->location, nullptr, {} ) );
-		}
-
-		auto caseStmt = mutStmt->stmts.back().strict_as<CaseStmt>();
+		if ( mutStmt->cases.empty() ) {
+			mutStmt->cases.push_back( new CaseClause( mutStmt->location, nullptr, {} ) );
+		}
+
+		auto caseStmt = mutStmt->cases.back().get();
 		auto mutCase = mutate( caseStmt );
-		mutStmt->stmts.back() = mutCase;
+		mutStmt->cases.back() = mutCase;
 
 		Label label( mutCase->location, "breakLabel" );
@@ -514,5 +513,5 @@
 }
 
-void MultiLevelExitCore::previsit( const FinallyStmt * ) {
+void MultiLevelExitCore::previsit( const FinallyClause * ) {
 	GuardAction([this, old = move( enclosing_control_structures)](){ enclosing_control_structures = move(old); });
 	enclosing_control_structures = vector<Entry>();
Index: src/InitTweak/InitTweak.cc
===================================================================
--- src/InitTweak/InitTweak.cc	(revision f5bace8ecd312e656098f5267daf64c5b419bcb4)
+++ src/InitTweak/InitTweak.cc	(revision 400b8bec42ab40f3a00bc24c1485bc941ead2174)
@@ -423,5 +423,5 @@
 				loc, targetLabel.newName(), { new ast::Attribute{ "unused" } } };
 
-			std::vector< ast::ptr< ast::Stmt > > branches;
+			std::vector< ast::ptr< ast::CaseClause > > branches;
 			for ( const ast::Init * init : *listInit ) {
 				auto condition = ast::ConstantExpr::from_ulong( loc, cond );
@@ -432,5 +432,5 @@
 				stmts.emplace_back(
 					new ast::BranchStmt{ loc, ast::BranchStmt::Break, switchLabel } );
-				branches.emplace_back( new ast::CaseStmt{ loc, condition, std::move( stmts ) } );
+				branches.emplace_back( new ast::CaseClause{ loc, condition, std::move( stmts ) } );
 			}
 			out.emplace_back( new ast::SwitchStmt{ loc, index, std::move( branches ) } );
Index: src/ResolvExpr/Resolver.cc
===================================================================
--- src/ResolvExpr/Resolver.cc	(revision f5bace8ecd312e656098f5267daf64c5b419bcb4)
+++ src/ResolvExpr/Resolver.cc	(revision 400b8bec42ab40f3a00bc24c1485bc941ead2174)
@@ -1281,10 +1281,10 @@
 		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,5 +1615,5 @@
 	}
 
-	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,5 +1631,5 @@
 			}
 
-			caseStmt = ast::mutate_field( caseStmt, &ast::CaseStmt::cond, newExpr );
+			caseStmt = ast::mutate_field( caseStmt, &ast::CaseClause::cond, newExpr );
 		}
 		return caseStmt;
@@ -1674,33 +1674,33 @@
 	}
 
-	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;
 	}