Index: src/AST/Pass.hpp
===================================================================
--- src/AST/Pass.hpp	(revision ee918356dcc048f90ed4b21640445b45bf2a0d4c)
+++ src/AST/Pass.hpp	(revision f53afafb9048d059a73cca286f45a8bfc99cc3e4)
@@ -239,90 +239,32 @@
 private:
 
-	// Regular nodes
+	__pass::result1<ast::Stmt> call_accept( const ast::Stmt * );
+	__pass::result1<ast::Expr> call_accept( const ast::Expr * );
+
+	/// This has a `type` member that is the return type for the
+	/// generic call_accept if the generic call_accept is defined.
 	template< typename node_t >
-	struct result1 {
-		bool differs;
-		const node_t * value;
-
-		template< typename object_t, typename super_t, typename field_t >
-		void apply(object_t *, field_t super_t::* field);
-	};
-
-	result1<ast::Stmt> call_accept( const ast::Stmt * );
-	result1<ast::Expr> call_accept( const ast::Expr * );
+	using generic_call_accept_result =
+		std::enable_if<
+				!std::is_base_of<ast::Expr, node_t>::value &&
+				!std::is_base_of<ast::Stmt, node_t>::value
+			, __pass::result1<
+				typename std::remove_pointer< typename std::result_of<
+					decltype(&node_t::accept)(node_t*, type&) >::type >::type
+			>
+		>;
 
 	template< typename node_t >
 	auto call_accept( const node_t * node )
-		-> typename std::enable_if<
-				!std::is_base_of<ast::Expr, node_t>::value &&
-				!std::is_base_of<ast::Stmt, node_t>::value
-			, result1<
-				typename std::remove_pointer< decltype( node->accept(*this) ) >::type
-			>
-		>::type;
+		-> typename generic_call_accept_result<node_t>::type;
 
 	// requests WithStmtsToAdd directly add to this statement, as if it is a compound.
-	result1<ast::Stmt> call_accept_as_compound(const ast::Stmt *);
-
-	// Container of statements
+	__pass::result1<ast::Stmt> call_accept_as_compound(const ast::Stmt *);
+
 	template< template <class...> class container_t >
-	struct resultNstmt {
-		struct delta {
-			ptr<Stmt> nval;
-			ssize_t old_idx;
-			bool is_old;
-
-			delta(const Stmt * s, ssize_t i, bool old) : nval{s}, old_idx{i}, is_old{old} {}
-		};
-
-		bool differs;
-		container_t< delta > values;
-
-		resultNstmt() : differs(false), values{} {}
-		resultNstmt(bool diff, container_t< delta > && vals) : differs(diff), values(vals) {}
-
-		template< typename object_t, typename super_t, typename field_t >
-		void apply(object_t *, field_t super_t::* field);
-
-		template< template <class...> class incontainer_t >
-		void take_all( incontainer_t<ast::ptr<ast::Stmt>> * stmts ) {
-			if(!stmts || stmts->empty()) return;
-
-			std::transform(stmts->begin(), stmts->end(), std::back_inserter( values ), [](ast::ptr<ast::Stmt>& decl) -> delta {
-					return delta( decl.release(), -1, false );
-				});
-			stmts->clear();
-			differs = true;
-		}
-
-		template< template <class...> class incontainer_t >
-		void take_all( incontainer_t<ast::ptr<ast::Decl>> * decls ) {
-			if(!decls || decls->empty()) return;
-
-			std::transform(decls->begin(), decls->end(), std::back_inserter( values ), [](ast::ptr<ast::Decl>& decl) -> auto {
-					auto loc = decl->location;
-					auto stmt = new DeclStmt( loc, decl.release() );
-					return delta( stmt, -1, false );
-				});
-			decls->clear();
-			differs = true;
-		}
-	};
-
-	template< template <class...> class container_t >
-	resultNstmt<container_t> call_accept( const container_t< ptr<Stmt> > & );
-
-	// Container of something
+	__pass::resultNstmt<container_t> call_accept( const container_t< ptr<Stmt> > & );
+
 	template< template <class...> class container_t, typename node_t >
-	struct resultN {
-		bool differs;
-		container_t<ptr<node_t>> values;
-
-		template< typename object_t, typename super_t, typename field_t >
-		void apply(object_t *, field_t super_t::* field);
-	};
-
-	template< template <class...> class container_t, typename node_t >
-	resultN< container_t, node_t > call_accept( const container_t< ptr<node_t> > & container );
+	__pass::resultN< container_t, node_t > call_accept( const container_t< ptr<node_t> > & container );
 
 public: