Index: src/AST/Convert.cpp
===================================================================
--- src/AST/Convert.cpp	(revision 74dbbf628a225cb17200fe7c93c8b6b655aed9f0)
+++ src/AST/Convert.cpp	(revision 675d8166196da4f57bc368b82d7a4641323e2570)
@@ -10,6 +10,6 @@
 // Created On       : Thu May 09 15::37::05 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri May 17 12:13:00 2019
-// Update Count     : 3
+// Last Modified On : Fri May 17 16:01:00 2019
+// Update Count     : 4
 //
 
@@ -42,17 +42,56 @@
 //================================================================================================
 class ConverterNewToOld : public ast::Visitor {
+	BaseSyntaxNode * node = nullptr;
+
+	template<typename T>
+	struct Getter {
+		ConverterNewToOld & visitor;
+
+		template<typename U>
+		T * accept1( const ast::ptr<U> & ptr ) {
+			ptr->accept( visitor );
+			T * ret = strict_dynamic_cast< T * >( visitor.node );
+			visitor.node = nullptr;
+			return ret;
+		}
+
+		template<typename U>
+		std::list< T * > acceptL( const U & container ) {
+			std::list< T * > ret;
+			for (auto ptr : container ) {
+				ret.emplace_back( accept1( ptr ) );
+			}
+			return ret;
+		}
+	};
+
+    template<typename T>
+    Getter<T> get() {
+        return Getter<T>{ *this };
+    }
+
+	Label makeLabel(Statement * labelled, const ast::Label& label) {
+		return Label(
+			label.name,
+			labelled,
+			get<Attribute>().acceptL(label.attributes)
+		);
+	}
+
+	template<template <class...> class C>
+	std::list<Label> makeLabelL(Statement * labelled, const C<ast::Label>& labels) {
+		std::list<Label> ret;
+		for (auto label : labels) {
+			ret.push_back( makeLabel(labelled, label) );
+		}
+		return ret;
+	}
+
 public:
-	template<typename T>
-	T * get() {
-		T * ret = strict_dynamic_cast< T * >( node );
-		node = nullptr;
-		return ret;
+	Declaration * decl( const ast::Decl * declNode ) {
+		return get<Declaration>().accept1( ast::ptr<ast::Decl>( declNode ) );
 	}
 
 private:
-	BaseSyntaxNode * node = nullptr;
-
-	// All the visit functions:
-
 	const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
 		(void)node;
@@ -106,95 +145,264 @@
 
 	const ast::CompoundStmt * visit( const ast::CompoundStmt * node ) override final {
-		(void)node;
+		auto stmt = new CompoundStmt( get<Statement>().acceptL( node->kids ) );
+		stmt->location = node->location;
+		stmt->labels = makeLabelL( stmt, node->labels );
+		this->node = stmt;
 		return nullptr;
 	}
 
 	const ast::Stmt * visit( const ast::ExprStmt * node ) override final {
-		(void)node;
+		auto stmt = new ExprStmt( get<Expression>().accept1( node->expr ) );
+		stmt->location = node->location;
+		stmt->labels = makeLabelL( stmt, node->labels );
+		this->node = stmt;
 		return nullptr;
 	}
 
 	const ast::Stmt * visit( const ast::AsmStmt * node ) override final {
-		(void)node;
+		auto stmt = new AsmStmt(
+			node->isVolatile,
+			get<Expression>().accept1( node->instruction ),
+			get<Expression>().acceptL( node->output ),
+			get<Expression>().acceptL( node->input ),
+			get<ConstantExpr>().acceptL( node->clobber ),
+			makeLabelL( nullptr, node->gotoLabels ) // What are these labelling?
+		);
+		stmt->location = node->location;
+		stmt->labels = makeLabelL( stmt, node->labels );
+		this->node = stmt;
 		return nullptr;
 	}
 
 	const ast::Stmt * visit( const ast::DirectiveStmt * node ) override final {
-		(void)node;
+		auto stmt = new DirectiveStmt( node->directive );
+		stmt->location = node->location;
+		stmt->labels = makeLabelL( stmt, node->labels );
+		this->node = stmt;
 		return nullptr;
 	}
 
 	const ast::Stmt * visit( const ast::IfStmt * node ) override final {
-		(void)node;
+		auto stmt = new IfStmt(
+			get<Expression>().accept1( node->cond ),
+			get<Statement>().accept1( node->thenPart ),
+			get<Statement>().accept1( node->elsePart ),
+			get<Statement>().acceptL( node->inits )
+		);
+		stmt->location = node->location;
+		stmt->labels = makeLabelL( stmt, node->labels );
+		this->node = stmt;
+		return nullptr;
+	}
+
+	const ast::Stmt * visit( const ast::SwitchStmt * node ) override final {
+		auto stmt = new SwitchStmt(
+			get<Expression>().accept1( node->cond ),
+			get<Statement>().acceptL( node->stmts )
+		);
+		stmt->location = node->location;
+		stmt->labels = makeLabelL( stmt, node->labels );
+		this->node = stmt;
+		return nullptr;
+	}
+
+	const ast::Stmt * visit( const ast::CaseStmt * node ) override final {
+		auto stmt = new CaseStmt(
+			get<Expression>().accept1( node->cond ),
+			get<Statement>().acceptL( node->stmts ),
+			node->isDefault()
+		);
+		stmt->location = node->location;
+		stmt->labels = makeLabelL( stmt, node->labels );
+		this->node = stmt;
 		return nullptr;
 	}
 
 	const ast::Stmt * visit( const ast::WhileStmt * node ) override final {
-		(void)node;
+		auto inits = get<Statement>().acceptL( node->inits );
+		auto stmt = new WhileStmt(
+			get<Expression>().accept1( node->cond ),
+			get<Statement>().accept1( node->body ),
+			inits,
+			node->isDoWhile
+		);
+		stmt->location = node->location;
+		stmt->labels = makeLabelL( stmt, node->labels );
+		this->node = stmt;
 		return nullptr;
 	}
 
 	const ast::Stmt * visit( const ast::ForStmt * node ) override final {
-		(void)node;
-		return nullptr;
-	}
-
-	const ast::Stmt * visit( const ast::SwitchStmt * node ) override final {
-		(void)node;
-		return nullptr;
-	}
-
-	const ast::Stmt * visit( const ast::CaseStmt * node ) override final {
-		(void)node;
+		auto stmt = new ForStmt(
+			get<Statement>().acceptL( node->inits ),
+			get<Expression>().accept1( node->cond ),
+			get<Expression>().accept1( node->inc ),
+			get<Statement>().accept1( node->body )
+		);
+		stmt->location = node->location;
+		stmt->labels = makeLabelL( stmt, node->labels );
+		this->node = stmt;
 		return nullptr;
 	}
 
 	const ast::Stmt * visit( const ast::BranchStmt * node ) override final {
-		(void)node;
+		BranchStmt * stmt;
+		if (node->computedTarget) {
+			stmt = new BranchStmt( get<Expression>().accept1( node->computedTarget ),
+				BranchStmt::Goto );
+		} else {
+			BranchStmt::Type type;
+			switch (node->kind) {
+			#define CASE(n) \
+			case ast::BranchStmt::n: \
+				type = BranchStmt::n; \
+				break
+			CASE(Goto);
+			CASE(Break);
+			CASE(Continue);
+			CASE(FallThrough);
+			CASE(FallThroughDefault);
+			#undef CASE
+			default:
+				assertf(false, "Invalid ast::BranchStmt::Kind: %d\n", node->kind);
+			}
+
+			// The labels here are also weird.
+			stmt = new BranchStmt( makeLabel( nullptr, node->originalTarget ), type );
+			stmt->target = makeLabel( stmt, node->target );
+		}
+		stmt->location = node->location;
+		stmt->labels = makeLabelL( stmt, node->labels );
+		this->node = stmt;
 		return nullptr;
 	}
 
 	const ast::Stmt * visit( const ast::ReturnStmt * node ) override final {
-		(void)node;
+		auto stmt = new ReturnStmt( get<Expression>().accept1( node->expr ) );
+		stmt->location = node->location;
+		stmt->labels = makeLabelL( stmt, node->labels );
+		this->node = stmt;
 		return nullptr;
 	}
 
 	const ast::Stmt * visit( const ast::ThrowStmt * node ) override final {
-		(void)node;
+		ThrowStmt::Kind kind;
+		switch (node->kind) {
+		case ast::ThrowStmt::Terminate:
+			kind = ThrowStmt::Terminate;
+			break;
+		case ast::ThrowStmt::Resume:
+			kind = ThrowStmt::Resume;
+			break;
+		default:
+			assertf(false, "Invalid ast::ThrowStmt::Kind: %d\n", node->kind);
+		}
+		auto stmt = new ThrowStmt(
+			kind,
+			get<Expression>().accept1( node->expr ),
+			get<Expression>().accept1( node->target )
+		);
+		stmt->location = node->location;
+		stmt->labels = makeLabelL( stmt, node->labels );
+		this->node = stmt;
 		return nullptr;
 	}
 
 	const ast::Stmt * visit( const ast::TryStmt * node ) override final {
-		(void)node;
+		auto handlers = get<CatchStmt>().acceptL( node->handlers );
+		auto stmt = new TryStmt(
+			get<CompoundStmt>().accept1( node->body ),
+			handlers,
+			get<FinallyStmt>().accept1( node->finally )
+		);
+		stmt->location = node->location;
+		stmt->labels = makeLabelL( stmt, node->labels );
+		this->node = stmt;
 		return nullptr;
 	}
 
 	const ast::Stmt * visit( const ast::CatchStmt * node ) override final {
-		(void)node;
+		CatchStmt::Kind kind;
+		switch (node->kind) {
+		case ast::CatchStmt::Terminate:
+			kind = CatchStmt::Terminate;
+			break;
+		case ast::CatchStmt::Resume:
+			kind = CatchStmt::Resume;
+			break;
+		default:
+			assertf(false, "Invalid ast::CatchStmt::Kind: %d\n", node->kind);
+		}
+		auto stmt = new CatchStmt(
+			kind,
+			get<Declaration>().accept1( node->decl ),
+			get<Expression>().accept1( node->cond ),
+			get<Statement>().accept1( node->body )
+		);
+		stmt->location = node->location;
+		stmt->labels = makeLabelL( stmt, node->labels );
+		this->node = stmt;
 		return nullptr;
 	}
 
 	const ast::Stmt * visit( const ast::FinallyStmt * node ) override final {
-		(void)node;
+		auto stmt = new FinallyStmt( get<CompoundStmt>().accept1( node->body ) );
+		stmt->location = node->location;
+		stmt->labels = makeLabelL( stmt, node->labels );
+		this->node = stmt;
 		return nullptr;
 	}
 
 	const ast::Stmt * visit( const ast::WaitForStmt * node ) override final {
-		(void)node;
+		auto stmt = new WaitForStmt;
+		stmt->clauses.reserve( node->clauses.size() );
+		for ( auto clause : node->clauses ) {
+			stmt->clauses.push_back({{
+					get<Expression>().accept1( clause.target.function ),
+					get<Expression>().acceptL( clause.target.arguments ),
+				},
+				get<Statement>().accept1( clause.stmt ),
+				get<Expression>().accept1( clause.cond ),
+			});
+		}
+		stmt->timeout = {
+			get<Expression>().accept1( node->timeout.time ),
+			get<Statement>().accept1( node->timeout.stmt ),
+			get<Expression>().accept1( node->timeout.cond ),
+		};
+		stmt->orelse = {
+			get<Statement>().accept1( node->orElse.stmt ),
+			get<Expression>().accept1( node->orElse.cond ),
+		};
+		stmt->location = node->location;
+		stmt->labels = makeLabelL( stmt, node->labels );
+		this->node = stmt;
 		return nullptr;
 	}
 
 	const ast::Stmt * visit( const ast::WithStmt * node ) override final {
-		(void)node;
+		auto stmt = new WithStmt(
+			get<Expression>().acceptL( node->exprs ),
+			get<Statement>().accept1( node->stmt )
+		);
+		stmt->location = node->location;
+		stmt->labels = makeLabelL( stmt, node->labels );
+		this->node = stmt;
 		return nullptr;
 	}
 
 	const ast::NullStmt * visit( const ast::NullStmt * node ) override final {
-		(void)node;
+		auto stmt = new NullStmt();
+		stmt->location = node->location;
+		stmt->labels = makeLabelL( stmt, node->labels );
+		this->node = stmt;
 		return nullptr;
 	}
 
 	const ast::Stmt * visit( const ast::DeclStmt * node ) override final {
-		(void)node;
+		auto stmt = new DeclStmt( get<Declaration>().accept1( node->decl ) );
+		stmt->location = node->location;
+		stmt->labels = makeLabelL( stmt, node->labels );
+		this->node = stmt;
 		return nullptr;
 	}
@@ -496,9 +704,4 @@
 
 	const ast::Init * visit( const ast::ConstructorInit * node ) override final {
-		(void)node;
-		return nullptr;
-	}
-
-	const ast::Constant * visit( const ast::Constant * node ) override final {
 		(void)node;
 		return nullptr;
@@ -520,6 +723,5 @@
 	std::list< Declaration * > decls;
 	for(auto d : translationUnit) {
-		d->accept( c );
-		decls.emplace_back( c.get<Declaration>() );
+		decls.emplace_back( c.decl( d ) );
 		delete d;
 	}
Index: src/AST/Stmt.hpp
===================================================================
--- src/AST/Stmt.hpp	(revision 74dbbf628a225cb17200fe7c93c8b6b655aed9f0)
+++ src/AST/Stmt.hpp	(revision 675d8166196da4f57bc368b82d7a4641323e2570)
@@ -10,6 +10,6 @@
 // Created On       : Wed May  8 13:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri May 17 10:03:00 2019
-// Update Count     : 4
+// Last Modified On : Fri May 17 12:45:00 2019
+// Update Count     : 5
 //
 
@@ -175,5 +175,5 @@
 	: Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
 
-	bool isDefault() { return !cond; }
+	bool isDefault() const { return !cond; }
 
 	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }