Index: src/AST/Convert.cpp
===================================================================
--- src/AST/Convert.cpp	(revision 8631c84430f939e4e010601d6c8078fd00d2182a)
+++ src/AST/Convert.cpp	(revision 8e819a94d8115bf4605e13dfbb79f504db752d6e)
@@ -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 8631c84430f939e4e010601d6c8078fd00d2182a)
+++ src/AST/Fwd.hpp	(revision 8e819a94d8115bf4605e13dfbb79f504db752d6e)
@@ -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 8631c84430f939e4e010601d6c8078fd00d2182a)
+++ src/AST/Node.cpp	(revision 8e819a94d8115bf4605e13dfbb79f504db752d6e)
@@ -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 8631c84430f939e4e010601d6c8078fd00d2182a)
+++ src/AST/Pass.hpp	(revision 8e819a94d8115bf4605e13dfbb79f504db752d6e)
@@ -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 8631c84430f939e4e010601d6c8078fd00d2182a)
+++ src/AST/Pass.impl.hpp	(revision 8e819a94d8115bf4605e13dfbb79f504db752d6e)
@@ -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 8631c84430f939e4e010601d6c8078fd00d2182a)
+++ src/AST/Print.cpp	(revision 8e819a94d8115bf4605e13dfbb79f504db752d6e)
@@ -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 8631c84430f939e4e010601d6c8078fd00d2182a)
+++ src/AST/Stmt.hpp	(revision 8e819a94d8115bf4605e13dfbb79f504db752d6e)
@@ -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 8631c84430f939e4e010601d6c8078fd00d2182a)
+++ src/AST/Visitor.hpp	(revision 8e819a94d8115bf4605e13dfbb79f504db752d6e)
@@ -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;