Index: libcfa/src/concurrency/coroutine.cfa
===================================================================
--- libcfa/src/concurrency/coroutine.cfa	(revision 848439f8d6e456a0269c3145cc6faa97e77d4637)
+++ libcfa/src/concurrency/coroutine.cfa	(revision 69c5c001921edf7a77ff0c53ac4f0d0e8044b405)
@@ -47,6 +47,5 @@
 
 //-----------------------------------------------------------------------------
-FORALL_DATA_INSTANCE(CoroutineCancelled,
-		(dtype coroutine_t | sized(coroutine_t)), (coroutine_t))
+FORALL_DATA_INSTANCE(CoroutineCancelled, (dtype coroutine_t), (coroutine_t))
 
 struct __cfaehm_node {
@@ -59,5 +58,5 @@
 void mark_exception(CoroutineCancelled(T) *) {}
 
-forall(dtype T | sized(T))
+forall(dtype T)
 void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src) {
 	dst->the_coroutine = src->the_coroutine;
@@ -77,5 +76,7 @@
 	exception_t * except = (exception_t *)(1 + (__cfaehm_node *)desc->cancellation);
 
+	// TODO: Remove explitate vtable set once trac#186 is fixed.
 	CoroutineCancelled(T) except;
+	except.virtual_table = &get_exception_vtable(&except);
 	except.the_coroutine = &cor;
 	except.the_exception = except;
Index: libcfa/src/concurrency/coroutine.hfa
===================================================================
--- libcfa/src/concurrency/coroutine.hfa	(revision 848439f8d6e456a0269c3145cc6faa97e77d4637)
+++ libcfa/src/concurrency/coroutine.hfa	(revision 69c5c001921edf7a77ff0c53ac4f0d0e8044b405)
@@ -22,7 +22,5 @@
 //-----------------------------------------------------------------------------
 // Exception thrown from resume when a coroutine stack is cancelled.
-// Should not have to be be sized (see trac #196).
-FORALL_DATA_EXCEPTION(CoroutineCancelled,
-		(dtype coroutine_t | sized(coroutine_t)), (coroutine_t)) (
+FORALL_DATA_EXCEPTION(CoroutineCancelled, (dtype coroutine_t), (coroutine_t)) (
 	coroutine_t * the_coroutine;
 	exception_t * the_exception;
@@ -30,7 +28,4 @@
 
 forall(dtype T)
-void mark_exception(CoroutineCancelled(T) *);
-
-forall(dtype T | sized(T))
 void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src);
 
@@ -42,7 +37,7 @@
 // Anything that implements this trait can be resumed.
 // Anything that is resumed is a coroutine.
-trait is_coroutine(dtype T | sized(T)
-		| is_resumption_exception(CoroutineCancelled(T))
-		| VTABLE_ASSERTION(CoroutineCancelled, (T))) {
+trait is_coroutine(dtype T
+		| is_resumption_exception(CoroutineCancelled(T),
+			CoroutineCancelled_vtable(T))) {
 	void main(T & this);
 	$coroutine * get_coroutine(T & this);
Index: libcfa/src/exception.h
===================================================================
--- libcfa/src/exception.h	(revision 848439f8d6e456a0269c3145cc6faa97e77d4637)
+++ libcfa/src/exception.h	(revision 69c5c001921edf7a77ff0c53ac4f0d0e8044b405)
@@ -76,21 +76,21 @@
 // implemented in the .c file either so they all have to be inline.
 
-trait is_exception(dtype exceptT) {
+trait is_exception(dtype exceptT, dtype virtualT) {
 	/* The first field must be a pointer to a virtual table.
-	 * That virtual table must be a decendent of the base exception virtual tab$
+	 * That virtual table must be a decendent of the base exception virtual table.
 	 */
-	void mark_exception(exceptT *);
-	// This is never used and should be a no-op.
+	virtualT const & get_exception_vtable(exceptT *);
+	// Always returns the virtual table for this type (associated types hack).
 };
 
-trait is_termination_exception(dtype exceptT | is_exception(exceptT)) {
+trait is_termination_exception(dtype exceptT, dtype virtualT | is_exception(exceptT, virtualT)) {
 	void defaultTerminationHandler(exceptT &);
 };
 
-trait is_resumption_exception(dtype exceptT | is_exception(exceptT)) {
+trait is_resumption_exception(dtype exceptT, dtype virtualT | is_exception(exceptT, virtualT)) {
 	void defaultResumptionHandler(exceptT &);
 };
 
-forall(dtype exceptT | is_termination_exception(exceptT))
+forall(dtype exceptT, dtype virtualT | is_termination_exception(exceptT, virtualT))
 static inline void $throw(exceptT & except) {
 	__cfaehm_throw_terminate(
@@ -100,5 +100,5 @@
 }
 
-forall(dtype exceptT | is_resumption_exception(exceptT))
+forall(dtype exceptT, dtype virtualT | is_resumption_exception(exceptT, virtualT))
 static inline void $throwResume(exceptT & except) {
 	__cfaehm_throw_resume(
@@ -108,15 +108,15 @@
 }
 
-forall(dtype exceptT | is_exception(exceptT))
+forall(dtype exceptT, dtype virtualT | is_exception(exceptT, virtualT))
 static inline void cancel_stack(exceptT & except) __attribute__((noreturn)) {
 	__cfaehm_cancel_stack( (exception_t *)&except );
 }
 
-forall(dtype exceptT | is_exception(exceptT))
+forall(dtype exceptT, dtype virtualT | is_exception(exceptT, virtualT))
 static inline void defaultTerminationHandler(exceptT & except) {
 	return cancel_stack( except );
 }
 
-forall(dtype exceptT | is_exception(exceptT))
+forall(dtype exceptT, dtype virtualT | is_exception(exceptT, virtualT))
 static inline void defaultResumptionHandler(exceptT & except) {
 	throw except;
Index: libcfa/src/exception.hfa
===================================================================
--- libcfa/src/exception.hfa	(revision 848439f8d6e456a0269c3145cc6faa97e77d4637)
+++ libcfa/src/exception.hfa	(revision 69c5c001921edf7a77ff0c53ac4f0d0e8044b405)
@@ -95,5 +95,5 @@
 // visible anywhere you use the instantiation of the exception is used.
 #define POLY_VTABLE_DECLARATION(exception_name, ...) \
-	void mark_exception(exception_name(__VA_ARGS__) *); \
+	VTABLE_TYPE(exception_name)(__VA_ARGS__) const & get_exception_vtable(exception_name(__VA_ARGS__) *); \
 	extern VTABLE_TYPE(exception_name)(__VA_ARGS__) VTABLE_NAME(exception_name)
 
@@ -160,10 +160,11 @@
 
 #define _FORALL_CTOR0_DECLARATION(exception_name, assertions, parameters) \
-	forall(_UNPACK assertions | VTABLE_ASSERTION(exception_name, parameters) ) \
+	forall(_UNPACK assertions | \
+		is_exception(exception_name parameters, VTABLE_TYPE(exception_name) parameters)) \
 	void ?{}(exception_name parameters & this)
 
 #define _FORALL_CTOR0_INSTANCE(exception_name, assertions, parameters) \
 	_FORALL_CTOR0_DECLARATION(exception_name, assertions, parameters) { \
-		VTABLE_INIT(this, exception_name); \
+		(this).virtual_table = &get_exception_vtable(&this); \
 	}
 
@@ -185,6 +186,6 @@
 #define _VTABLE_DECLARATION(exception_name, parent_name, ...) \
 	struct exception_name; \
-	void mark_exception(exception_name *); \
 	VTABLE_TYPE(exception_name); \
+	VTABLE_TYPE(exception_name) const & get_exception_vtable(exception_name *); \
 	extern VTABLE_TYPE(exception_name) VTABLE_NAME(exception_name); \
 	VTABLE_TYPE(exception_name) { \
@@ -197,5 +198,7 @@
 
 #define _VTABLE_INSTANCE(exception_name, parent_name, ...) \
-	void mark_exception(exception_name *) {} \
+	VTABLE_TYPE(exception_name) const & get_exception_vtable(exception_name *) { \
+		return VTABLE_NAME(exception_name); \
+	} \
 	void _GLUE2(exception_name,_copy)(exception_name * this, exception_name * other) { \
 		*this = *other; \
@@ -218,5 +221,9 @@
 
 #define _POLY_VTABLE_INSTANCE(exception_name, parent_name, ...) \
-	void mark_exception(exception_name(__VA_ARGS__) *) {} \
+	extern VTABLE_TYPE(exception_name)(__VA_ARGS__) VTABLE_NAME(exception_name); \
+	VTABLE_TYPE(exception_name)(__VA_ARGS__) const & get_exception_vtable( \
+			exception_name(__VA_ARGS__) *) { \
+		return VTABLE_NAME(exception_name); \
+	} \
 	void _GLUE2(exception_name,_copy)( \
 			exception_name(__VA_ARGS__) * this, exception_name(__VA_ARGS__) * other) { \