Index: src/AST/Convert.cpp
===================================================================
--- src/AST/Convert.cpp	(revision acd80b4ef35ce21c1d4fa9223b9a2250e9c8143a)
+++ src/AST/Convert.cpp	(revision 6f8e87dcf3d0ad0a04666c2efea62740d347610d)
@@ -9,7 +9,7 @@
 // Author           : Thierry Delisle
 // Created On       : Thu May 09 15::37::05 2019
-// Last Modified By :
-// Last Modified On :
-// Update Count     :
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu May 16 17:21:00 2019
+// Update Count     : 1
 //
 
@@ -74,19 +74,50 @@
 	ast::Node * node;
 
+	// Local Utilities:
+
+	template<typename NewT, typename OldT>
+	NewT * getAccept1( OldT old ) {
+		old->accept(*this);
+		return strict_dynamic_cast< NewT * >( node );
+	}
+
+#	define GET_ACCEPT_1(child, type) \
+		getAccept1< ast::type, decltype( old->child ) >( old->child )
+
+	template<typename NewT, typename OldC>
+	std::vector< ast::ptr<NewT> > getAcceptV( OldC& old ) {
+		std::vector< ast::ptr<NewT> > ret;
+		ret.reserve( old.size() );
+		for ( auto a : old ) {
+			a->accept( *this );
+			ret.emplace_back( strict_dynamic_cast< NewT * >(node) );
+		}
+		return ret;
+	}
+
+#	define GET_ACCEPT_V(child, type) \
+		getAcceptV< ast::type, decltype( old->child ) >( old->child )
+
+	ast::Label make_label(Label* old) {
+		return ast::Label(
+			old->labelled->location,
+			old->name,
+			GET_ACCEPT_V(attributes, Attribute)
+		);
+	}
+
 	template<template <class...> class C>
 	C<ast::Label> make_labels(C<Label> olds) {
 		C<ast::Label> ret;
-		for(auto oldn : olds) {
-			auto old = &oldn; // to reuse the MACRO
-			ACCEPT_N(attr, attributes, Attribute)
-			ast::Label l(
-				{},
-				old->get_name(),
-				to<std::vector>::from( std::move( attr ) )
-			);
-			ret.push_back( l );
+		for (auto oldn : olds) {
+			ret.push_back( make_label( &oldn ) );
 		}
 		return ret;
 	}
+
+#	define GET_LABELS_V(labels) \
+		to<std::vector>::from( make_labels( std::move( labels ) ) )
+
+	// Now all the visit functions:
 
 	virtual void visit( ObjectDecl * old ) override final {
@@ -258,89 +289,244 @@
 
 	virtual void visit( ExprStmt * old ) override final {
-		ACCEPT_1(expr, expr, Expr)
-		auto stmt = new ast::ExprStmt(
-			old->location,
-			expr
-		);
-		stmt->labels = to<std::vector>::from( make_labels( std::move( old->labels ) ) );
+		this->node = new ast::ExprStmt(
+			old->location,
+			GET_ACCEPT_1(expr, Expr),
+			GET_LABELS_V(old->labels)
+		);
+	}
+
+	virtual void visit( AsmStmt * old ) override final {
+		this->node = new ast::AsmStmt(
+			old->location,
+			old->voltile,
+			GET_ACCEPT_1(instruction, Expr),
+			GET_ACCEPT_V(output, Expr),
+			GET_ACCEPT_V(input, Expr),
+			GET_ACCEPT_V(clobber, ConstantExpr),
+			GET_LABELS_V(old->gotolabels),
+			GET_LABELS_V(old->labels)
+		);
+	}
+
+	virtual void visit( DirectiveStmt * old ) override final {
+		this->node = new ast::DirectiveStmt(
+			old->location,
+			old->directive,
+			GET_LABELS_V(old->labels)
+		);
+	}
+
+	virtual void visit( IfStmt * old ) override final {
+		this->node = new ast::IfStmt(
+			old->location,
+			GET_ACCEPT_1(condition, Expr),
+			GET_ACCEPT_1(thenPart, Stmt),
+			GET_ACCEPT_1(elsePart, Stmt),
+			GET_ACCEPT_V(initialization, Stmt),
+			GET_LABELS_V(old->labels)
+		);
+	}
+
+	virtual void visit( SwitchStmt * old ) override final {
+		this->node = new ast::SwitchStmt(
+			old->location,
+			GET_ACCEPT_1(condition, Expr),
+			GET_ACCEPT_V(statements, Stmt),
+			GET_LABELS_V(old->labels)
+		);
+	}
+
+	virtual void visit( CaseStmt * old ) override final {
+		this->node = new ast::CaseStmt(
+			old->location,
+			GET_ACCEPT_1(condition, Expr),
+			GET_ACCEPT_V(stmts, Stmt),
+			GET_LABELS_V(old->labels)
+		);
+	}
+
+	virtual void visit( WhileStmt * old ) override final {
+		this->node = new ast::WhileStmt(
+			old->location,
+			GET_ACCEPT_1(condition, Expr),
+			GET_ACCEPT_1(body, Stmt),
+			GET_ACCEPT_V(initialization, Stmt),
+			old->isDoWhile,
+			GET_LABELS_V(old->labels)
+		);
+	}
+
+	virtual void visit( ForStmt * old ) override final {
+		this->node = new ast::ForStmt(
+			old->location,
+			GET_ACCEPT_V(initialization, Stmt),
+			GET_ACCEPT_1(condition, Expr),
+			GET_ACCEPT_1(increment, Expr),
+			GET_ACCEPT_1(body, Stmt),
+			GET_LABELS_V(old->labels)
+		);
+	}
+
+	virtual void visit( BranchStmt * old ) override final {
+		if (old->computedTarget) {
+			this->node = new ast::BranchStmt(
+				old->location,
+				GET_ACCEPT_1(computedTarget, Expr),
+				GET_LABELS_V(old->labels)
+			);
+		} else {
+			ast::BranchStmt::Kind kind;
+			switch (old->type) {
+			#define CASE(n) \
+			case BranchStmt::n: \
+				kind = ast::BranchStmt::n; \
+				break
+			CASE(Goto);
+			CASE(Break);
+			CASE(Continue);
+			CASE(FallThrough);
+			CASE(FallThroughDefault);
+			#undef CASE
+			}
+
+			Label label = old->originalTarget;
+			auto stmt = new ast::BranchStmt(
+				old->location,
+				kind,
+				make_label(&label),
+				GET_LABELS_V(old->labels)
+			);
+			stmt->target = make_label(&old->target);
+			this->node = stmt;
+		}
+	}
+
+	virtual void visit( ReturnStmt * old ) override final {
+		this->node = new ast::ReturnStmt(
+			old->location,
+			GET_ACCEPT_1(expr, Expr),
+			GET_LABELS_V(old->labels)
+		);
+	}
+
+	virtual void visit( ThrowStmt * old ) override final {
+		ast::ThrowStmt::Kind kind;
+		switch (old->kind) {
+		case ThrowStmt::Terminate:
+			kind = ast::ThrowStmt::Terminate;
+			break;
+		case ThrowStmt::Resume:
+			kind = ast::ThrowStmt::Resume;
+			break;
+		}
+
+		this->node = new ast::ThrowStmt(
+			old->location,
+			kind,
+			GET_ACCEPT_1(expr, Expr),
+			GET_ACCEPT_1(target, Expr),
+			GET_LABELS_V(old->labels)
+		);
+	}
+
+	virtual void visit( TryStmt * old ) override final {
+		this->node = new ast::TryStmt(
+			old->location,
+			GET_ACCEPT_1(block, CompoundStmt),
+			GET_ACCEPT_V(handlers, CatchStmt),
+			GET_ACCEPT_1(finallyBlock, FinallyStmt),
+			GET_LABELS_V(old->labels)
+		);
+	}
+
+	virtual void visit( CatchStmt * old ) override final {
+		ast::CatchStmt::Kind kind;
+		switch (old->kind) {
+		case CatchStmt::Terminate:
+			kind = ast::CatchStmt::Terminate;
+			break;
+		case CatchStmt::Resume:
+			kind = ast::CatchStmt::Resume;
+			break;
+		}
+
+		this->node = new ast::CatchStmt(
+			old->location,
+			kind,
+			GET_ACCEPT_1(decl, Decl),
+			GET_ACCEPT_1(cond, Expr),
+			GET_ACCEPT_1(body, Stmt),
+			GET_LABELS_V(old->labels)
+		);
+	}
+
+	virtual void visit( FinallyStmt * old ) override final {
+		this->node = new ast::FinallyStmt(
+			old->location,
+			GET_ACCEPT_1(block, CompoundStmt),
+			GET_LABELS_V(old->labels)
+		);
+	}
+
+	virtual void visit( WaitForStmt * old ) override final {
+		ast::WaitForStmt * stmt = new ast::WaitForStmt(
+			old->location,
+			GET_LABELS_V(old->labels)
+		);
+
+		stmt->clauses.reserve( old->clauses.size() );
+		for (size_t i = 0 ; i < old->clauses.size() ; ++i) {
+			stmt->clauses.push_back({
+				ast::WaitForStmt::Target{
+					GET_ACCEPT_1(clauses[i].target.function, Expr),
+					GET_ACCEPT_V(clauses[i].target.arguments, Expr)
+				},
+				GET_ACCEPT_1(clauses[i].statement, Stmt),
+				GET_ACCEPT_1(clauses[i].condition, Expr)
+			});
+		}
+		stmt->timeout = {
+			GET_ACCEPT_1(timeout.time, Expr),
+			GET_ACCEPT_1(timeout.statement, Stmt),
+			GET_ACCEPT_1(timeout.condition, Expr),
+		};
+		stmt->orElse = {
+			GET_ACCEPT_1(timeout.statement, Stmt),
+			GET_ACCEPT_1(timeout.condition, Expr),
+		};
 
 		this->node = stmt;
 	}
 
-	virtual void visit( AsmStmt * ) override final {
-
-	}
-
-	virtual void visit( DirectiveStmt * ) override final {
-
-	}
-
-	virtual void visit( IfStmt * ) override final {
-
-	}
-
-	virtual void visit( WhileStmt * ) override final {
-
-	}
-
-	virtual void visit( ForStmt * ) override final {
-
-	}
-
-	virtual void visit( SwitchStmt * ) override final {
-
-	}
-
-	virtual void visit( CaseStmt * ) override final {
-
-	}
-
-	virtual void visit( BranchStmt * ) override final {
-
-	}
-
-	virtual void visit( ReturnStmt * ) override final {
-
-	}
-
-	virtual void visit( ThrowStmt * ) override final {
-
-	}
-
-	virtual void visit( TryStmt * ) override final {
-
-	}
-
-	virtual void visit( CatchStmt * ) override final {
-
-	}
-
-	virtual void visit( FinallyStmt * ) override final {
-
-	}
-
-	virtual void visit( WaitForStmt * ) override final {
-
-	}
-
-	virtual void visit( WithStmt * ) override final {
-
+	virtual void visit( WithStmt * old ) override final {
+		this->node = new ast::WithStmt(
+			old->location,
+			GET_ACCEPT_V(exprs, Expr),
+			GET_ACCEPT_1(stmt, Stmt),
+			GET_LABELS_V(old->labels)
+		);
 	}
 
 	virtual void visit( NullStmt * old ) override final {
-		auto stmt = new ast::NullStmt(
-			old->location,
-			to<std::vector>::from( make_labels( std::move( old->labels ) ) )
-		);
-
-		this->node = stmt;
-	}
-
-	virtual void visit( DeclStmt * ) override final {
-
-	}
-
-	virtual void visit( ImplicitCtorDtorStmt * ) override final {
-
+		this->node = new ast::NullStmt(
+			old->location,
+			GET_LABELS_V(old->labels)
+		);
+	}
+
+	virtual void visit( DeclStmt * old ) override final {
+		this->node = new ast::DeclStmt(
+			old->location,
+			GET_ACCEPT_1(decl, Decl),
+			GET_LABELS_V(old->labels)
+		);
+	}
+
+	virtual void visit( ImplicitCtorDtorStmt * old ) override final {
+		this->node = new ast::ImplicitCtorDtorStmt(
+			old->location,
+			GET_ACCEPT_1(callStmt, Stmt),
+			GET_LABELS_V(old->labels)
+		);
 	}
 
@@ -598,4 +784,8 @@
 	}
 };
+
+#undef GET_LABELS_V
+#undef GET_ACCEPT_V
+#undef GET_ACCEPT_1
 
 #undef ACCEPT_N
Index: src/AST/Stmt.hpp
===================================================================
--- src/AST/Stmt.hpp	(revision acd80b4ef35ce21c1d4fa9223b9a2250e9c8143a)
+++ src/AST/Stmt.hpp	(revision 6f8e87dcf3d0ad0a04666c2efea62740d347610d)
@@ -10,6 +10,6 @@
 // Created On       : Wed May  8 13:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed May 15 16:01:00 2019
-// Update Count     : 2
+// Last Modified On : Wed May 16 12:20:00 2019
+// Update Count     : 3
 //
 
@@ -86,5 +86,6 @@
 	ptr<Expr> expr;
 
-	ExprStmt( const CodeLocation & loc, const Expr * e ) : Stmt(loc), expr(e) {}
+	ExprStmt( const CodeLocation& loc, const Expr* e, std::vector<Label>&& labels = {} )
+	: Stmt(loc, std::move(labels)), expr(e) {}
 
 	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }