diff --git a/gi/pygi-array.c b/gi/pygi-array.c
index fceffc6..9dff53b 100644
--- a/gi/pygi-array.c
+++ b/gi/pygi-array.c
@@ -761,10 +761,8 @@ pygi_arg_garray_len_arg_setup (PyGIArgCache *arg_cache,
         seq_cache->len_arg_index = g_type_info_get_array_length (type_info);
 
         /* offset by self arg for methods and vfuncs */
-        if (seq_cache->len_arg_index >= 0 && callable_cache != NULL &&
-                (callable_cache->function_type == PYGI_FUNCTION_TYPE_METHOD ||
-                 callable_cache->function_type == PYGI_FUNCTION_TYPE_VFUNC)) {
-            seq_cache->len_arg_index += 1;
+        if (seq_cache->len_arg_index >= 0 && callable_cache != NULL) {
+            seq_cache->len_arg_index += callable_cache->args_offset;
         }
     }
 
diff --git a/gi/pygi-cache.c b/gi/pygi-cache.c
index 24bb1a4..f0708a6 100644
--- a/gi/pygi-cache.c
+++ b/gi/pygi-cache.c
@@ -117,25 +117,6 @@ pygi_arg_cache_free (PyGIArgCache *cache)
         g_slice_free (PyGIArgCache, cache);
 }
 
-void
-pygi_callable_cache_free (PyGICallableCache *cache)
-{
-    if (cache == NULL)
-        return;
-
-    g_slist_free (cache->to_py_args);
-    g_slist_free (cache->arg_name_list);
-    g_hash_table_destroy (cache->arg_name_hash);
-    g_ptr_array_unref (cache->args_cache);
-
-    if (cache->return_cache != NULL)
-        pygi_arg_cache_free (cache->return_cache);
-
-    g_function_invoker_destroy (&cache->invoker);
-    g_slice_free (PyGICallableCache, cache);
-}
-
-
 /* PyGIInterfaceCache */
 
 static void
@@ -447,6 +428,8 @@ pygi_arg_cache_new (GITypeInfo *type_info,
     return arg_cache;
 }
 
+/* PyGICallableCache */
+
 static PyGIDirection
 _pygi_get_direction (PyGICallableCache *callable_cache, GIDirection gi_direction)
 {
@@ -454,11 +437,11 @@ _pygi_get_direction (PyGICallableCache *callable_cache, GIDirection gi_direction
     if (gi_direction == GI_DIRECTION_INOUT) {
         return PYGI_DIRECTION_BIDIRECTIONAL;
     } else if (gi_direction == GI_DIRECTION_IN) {
-        if (callable_cache->function_type == PYGI_FUNCTION_TYPE_CALLBACK)
+        if (callable_cache->calling_context != PYGI_CALLING_CONTEXT_IS_FROM_PY)
             return PYGI_DIRECTION_TO_PYTHON;
         return PYGI_DIRECTION_FROM_PYTHON;
     } else {
-        if (callable_cache->function_type == PYGI_FUNCTION_TYPE_CALLBACK)
+        if (callable_cache->calling_context != PYGI_CALLING_CONTEXT_IS_FROM_PY)
             return PYGI_DIRECTION_FROM_PYTHON;
         return PYGI_DIRECTION_TO_PYTHON;
     }
@@ -466,11 +449,11 @@ _pygi_get_direction (PyGICallableCache *callable_cache, GIDirection gi_direction
 
 /* Generate the cache for the callable's arguments */
 static gboolean
-_args_cache_generate (GICallableInfo *callable_info,
-                      PyGICallableCache *callable_cache)
+_callable_cache_generate_args_cache_real (PyGICallableCache *callable_cache,
+                                          GICallableInfo *callable_info)
 {
-    gssize arg_index = 0;
     gssize i;
+    gssize arg_index;
     GITypeInfo *return_info;
     GITransfer return_transfer;
     PyGIArgCache *return_cache;
@@ -500,41 +483,9 @@ _args_cache_generate (GICallableInfo *callable_info,
     callable_cache->return_cache = return_cache;
     g_base_info_unref (return_info);
 
-    /* first arg is the instance */
-    if (callable_cache->function_type == PYGI_FUNCTION_TYPE_METHOD ||
-            callable_cache->function_type == PYGI_FUNCTION_TYPE_VFUNC) {
-        GIInterfaceInfo *interface_info;
-        PyGIArgCache *instance_cache;
-
-        interface_info = g_base_info_get_container ( (GIBaseInfo *)callable_info);
-
-        instance_cache =
-            _arg_cache_new_for_interface (interface_info,
-                                          NULL,
-                                          NULL,
-                                          GI_TRANSFER_NOTHING,
-                                          PYGI_DIRECTION_FROM_PYTHON,
-                                          callable_cache);
-
-        g_base_info_unref ( (GIBaseInfo *)interface_info);
-
-        if (instance_cache == NULL)
-            return FALSE;
-
-        /* Because we are not supplied a GITypeInfo for instance arguments,
-         * assume some defaults. */
-        instance_cache->is_pointer = TRUE;
-        instance_cache->py_arg_index = 0;
-        instance_cache->c_arg_index = 0;
-
-        _pygi_callable_cache_set_arg (callable_cache, arg_index, instance_cache);
-
-        arg_index++;
-        callable_cache->n_py_args++;
-    }
-
-
-    for (i=0; arg_index < _pygi_callable_cache_args_len (callable_cache); arg_index++, i++) {
+    for (i = 0, arg_index = callable_cache->args_offset;
+         arg_index < _pygi_callable_cache_args_len (callable_cache);
+         i++, arg_index++) {
         PyGIArgCache *arg_cache = NULL;
         GIArgInfo *arg_info;
         PyGIDirection direction;
@@ -681,59 +632,35 @@ _args_cache_generate (GICallableInfo *callable_info,
     return TRUE;
 }
 
-static gboolean
-_setup_invoker (GICallableInfo *callable_info,
-                GIInfoType info_type,
-                GIFunctionInvoker *invoker,
-                GCallback function_ptr)
+static void
+_callable_cache_deinit_real (PyGICallableCache *cache)
 {
-    GError *error = NULL;
+    g_slist_free (cache->to_py_args);
+    g_slist_free (cache->arg_name_list);
+    g_hash_table_destroy (cache->arg_name_hash);
+    g_ptr_array_unref (cache->args_cache);
 
-    if (info_type == GI_INFO_TYPE_FUNCTION) {
-        if (g_function_info_prep_invoker ((GIFunctionInfo *)callable_info,
-                                          invoker,
-                                          &error)) {
-            return TRUE;
-        }
-        if (!pygi_error_check (&error)) {
-            PyErr_Format (PyExc_RuntimeError,
-                          "unknown error creating invoker for %s",
-                          g_base_info_get_name ((GIBaseInfo *)callable_info));
-        }
-        return FALSE;
+    if (cache->return_cache != NULL)
+        pygi_arg_cache_free (cache->return_cache);
 
-    } else {
-        if (!g_function_invoker_new_for_address (function_ptr,
-                                                 (GIFunctionInfo *)callable_info,
-                                                 invoker,
-                                                 &error)) {
-            if (!pygi_error_check (&error)) {
-                PyErr_Format (PyExc_RuntimeError,
-                              "unknown error creating invoker for %s",
-                              g_base_info_get_name ((GIBaseInfo *)callable_info));
-            }
-            return FALSE;
-        }
-    }
-    return TRUE;
+    if (cache->deinit == _callable_cache_deinit_real)
+        g_slice_free (PyGICallableCache, cache);
 }
 
-PyGICallableCache *
-pygi_callable_cache_new (GICallableInfo *callable_info,
-                         GCallback function_ptr,
-                         gboolean is_ccallback)
+static gboolean
+_callable_cache_init (PyGICallableCache *cache,
+                      GICallableInfo *callable_info)
 {
     gint n_args;
-    PyGICallableCache *cache;
-    GIInfoType type = g_base_info_get_type ( (GIBaseInfo *)callable_info);
 
-    cache = g_slice_new0 (PyGICallableCache);
+    if (cache->deinit == NULL)
+        cache->deinit = _callable_cache_deinit_real;
 
-    if (cache == NULL)
-        return NULL;
+    if (cache->generate_args_cache == NULL)
+        cache->generate_args_cache = _callable_cache_generate_args_cache_real;
 
-    cache->name = g_base_info_get_name ((GIBaseInfo *)callable_info);
-    cache->throws = g_callable_info_can_throw_gerror ((GIBaseInfo *)callable_info);
+    cache->name = g_base_info_get_name ((GIBaseInfo *) callable_info);
+    cache->throws = g_callable_info_can_throw_gerror ((GIBaseInfo *) callable_info);
 
     if (g_base_info_is_deprecated (callable_info)) {
         const gchar *deprecated = g_base_info_get_attribute (callable_info, "deprecated");
@@ -745,51 +672,398 @@ pygi_callable_cache_new (GICallableInfo *callable_info,
         else
             warning = g_strdup_printf ("%s.%s is deprecated",
                                        g_base_info_get_namespace (callable_info), cache->name);
-        PyErr_WarnEx(PyExc_DeprecationWarning, warning, 0);
+        PyErr_WarnEx (PyExc_DeprecationWarning, warning, 0);
         g_free (warning);
     }
 
-    if (type == GI_INFO_TYPE_FUNCTION) {
-        GIFunctionInfoFlags flags;
+    n_args = cache->args_offset + g_callable_info_get_n_args (callable_info);
+
+    if (n_args >= 0) {
+        cache->args_cache = g_ptr_array_new_full (n_args, (GDestroyNotify) pygi_arg_cache_free);
+        g_ptr_array_set_size (cache->args_cache, n_args);
+    }
+
+    if (!cache->generate_args_cache (cache, callable_info)) {
+        _callable_cache_deinit_real (cache);
+        return FALSE;
+    }
+
+    return TRUE;
+}
 
-        flags = g_function_info_get_flags ( (GIFunctionInfo *)callable_info);
+void
+pygi_callable_cache_free (PyGICallableCache *cache)
+{
+    cache->deinit (cache);
+}
 
-        if (flags & GI_FUNCTION_IS_CONSTRUCTOR)
-            cache->function_type = PYGI_FUNCTION_TYPE_CONSTRUCTOR;
-        else if (flags & GI_FUNCTION_IS_METHOD)
-            cache->function_type = PYGI_FUNCTION_TYPE_METHOD;
-    } else if (type == GI_INFO_TYPE_VFUNC) {
-        cache->function_type = PYGI_FUNCTION_TYPE_VFUNC;
-    } else if (type == GI_INFO_TYPE_CALLBACK) {
-        if (is_ccallback)
-            cache->function_type = PYGI_FUNCTION_TYPE_CCALLBACK;
-        else
-            cache->function_type = PYGI_FUNCTION_TYPE_CALLBACK;
+/* PyGIFunctionCache */
+
+static PyObject *
+_function_cache_invoke_real (PyGIFunctionCache *function_cache,
+                             PyGIInvokeState *state,
+                             PyObject *py_args, PyObject *py_kwargs)
+{
+    PyGICallableCache *cache = (PyGICallableCache *) function_cache;
+    PyObject *ret = NULL;
+
+    if (!pygi_invoke_state_init_from_cache (state, function_cache,
+                                            py_args, py_kwargs))
+         goto err;
+
+    if (!pygi_invoke_marshal_in_args (state, function_cache))
+         goto err;
+
+    if (!pygi_invoke_callable (state, function_cache))
+         goto err;
+
+    ret = pygi_invoke_marshal_out_args (state, function_cache);
+    pygi_marshal_cleanup_args_from_py_marshal_success (state, cache);
+
+    if (ret != NULL)
+        pygi_marshal_cleanup_args_to_py_marshal_success (state, cache);
+
+err:
+    pygi_invoke_state_clear (state, function_cache);
+    return ret;
+}
+
+static void
+_function_cache_deinit_real (PyGICallableCache *callable_cache)
+{
+    PyGIFunctionCache *function_cache = (PyGIFunctionCache *) callable_cache;
+
+    _callable_cache_deinit_real (callable_cache);
+
+    g_function_invoker_destroy (&function_cache->invoker);
+
+    if (callable_cache->deinit == _function_cache_deinit_real)
+        g_slice_free (PyGIFunctionCache, function_cache);
+}
+
+static gboolean
+_function_cache_init (PyGIFunctionCache *function_cache,
+                      GICallableInfo *callable_info)
+{
+    PyGICallableCache *callable_cache = (PyGICallableCache *) function_cache;
+    GIFunctionInvoker *invoker = &function_cache->invoker;
+    GError *error = NULL;
+
+    callable_cache->calling_context = PYGI_CALLING_CONTEXT_IS_FROM_PY;
+
+    if (callable_cache->deinit == NULL)
+        callable_cache->deinit = _function_cache_deinit_real;
+
+    if (function_cache->invoke == NULL)
+        function_cache->invoke = _function_cache_invoke_real;
+
+    /* Must be after setting up the calling context and vfuncs */
+    if (!_callable_cache_init (callable_cache, callable_info))
+        return FALSE;
+
+    /* Set by PyGICCallbackCache and PyGIVFuncCache */
+    if (invoker->native_address == NULL) {
+        if (g_function_info_prep_invoker ((GIFunctionInfo *) callable_info,
+                                          invoker,
+                                          &error)) {
+            return TRUE;
+        }
     } else {
-        cache->function_type = PYGI_FUNCTION_TYPE_METHOD;
+        if (g_function_invoker_new_for_address (invoker->native_address,
+                                                (GIFunctionInfo *) callable_info,
+                                                invoker,
+                                                &error)) {
+            return TRUE;
+        }
     }
 
-    n_args = g_callable_info_get_n_args (callable_info);
+    if (!pygi_error_check (&error)) {
+        PyErr_Format (PyExc_RuntimeError,
+                      "unknown error creating invoker for %s",
+                      g_base_info_get_name ((GIBaseInfo *) callable_info));
+    }
 
-    /* if we are a method or vfunc make sure the instance parameter is counted */
-    if (cache->function_type == PYGI_FUNCTION_TYPE_METHOD ||
-            cache->function_type == PYGI_FUNCTION_TYPE_VFUNC)
-        n_args++;
+    _callable_cache_deinit_real (callable_cache);
+    return FALSE;
+}
 
-    if (n_args >= 0) {
-        cache->args_cache = g_ptr_array_new_full (n_args, (GDestroyNotify) pygi_arg_cache_free);
-        g_ptr_array_set_size (cache->args_cache, n_args);
+PyGIFunctionCache *
+pygi_function_cache_new (GICallableInfo *info)
+{
+    PyGIFunctionCache *function_cache;
+
+    function_cache = g_slice_new0 (PyGIFunctionCache);
+
+    if (!_function_cache_init (function_cache, info)) {
+        g_slice_free (PyGIFunctionCache, function_cache);
+        return NULL;
     }
 
-    if (!_args_cache_generate (callable_info, cache))
-        goto err;
+    return function_cache;
+}
+
+PyObject *
+pygi_function_cache_invoke (PyGIFunctionCache *function_cache,
+                            PyObject *py_args, PyObject *py_kwargs)
+{
+    PyGIInvokeState state = { 0, };
+
+    return function_cache->invoke (function_cache, &state,
+                                   py_args, py_kwargs);
+}
+
+/* PyGICCallbackCache */
+
+PyGIFunctionCache *
+pygi_ccallback_cache_new (GICallableInfo *info,
+                          GCallback function_ptr)
+{
+    PyGICCallbackCache *ccallback_cache;
+    PyGIFunctionCache *function_cache;
+
+    ccallback_cache = g_slice_new0 (PyGICCallbackCache);
+    function_cache = (PyGIFunctionCache *) ccallback_cache;
+
+    function_cache->invoker.native_address = function_ptr;
 
-    if (!_setup_invoker (callable_info, type, &cache->invoker, function_ptr)) {
-        goto err;
+    if (!_function_cache_init (function_cache, info)) {
+        g_slice_free (PyGICCallbackCache, ccallback_cache);
+        return NULL;
+     }
+
+    return function_cache;
+}
+
+PyObject *
+pygi_ccallback_cache_invoke (PyGICCallbackCache *ccallback_cache,
+                             PyObject *py_args,
+                             PyObject *py_kwargs,
+                             gpointer user_data)
+{
+    PyGIFunctionCache *function_cache = (PyGIFunctionCache *) ccallback_cache;
+    PyGIInvokeState state = { 0, };
+
+    state.user_data = user_data;
+
+    return function_cache->invoke (function_cache, &state,
+                                   py_args, py_kwargs);
+}
+
+/* PyGIConstructorCache */
+
+static PyObject *
+_constructor_cache_invoke_real (PyGIFunctionCache *function_cache,
+                                PyGIInvokeState *state,
+                                PyObject *py_args,
+                                PyObject *py_kwargs)
+{
+    PyGICallableCache *cache = (PyGICallableCache *) function_cache;
+    PyObject *constructor_class;
+    PyObject *ret;
+
+    constructor_class = PyTuple_GetItem (py_args, 0);
+    if (constructor_class == NULL) {
+        PyErr_Clear ();
+        PyErr_Format (PyExc_TypeError,
+                      "Constructors require the class to be passed in as an argument, "
+                      "No arguments passed to the %s constructor.",
+                      ((PyGICallableCache *)function_cache)->name);
+
+        return FALSE;
     }
 
-    return cache;
-err:
-    pygi_callable_cache_free (cache);
+    py_args = PyTuple_GetSlice (py_args, 1, PyTuple_Size (py_args));
+    ret = _function_cache_invoke_real (function_cache, state, py_args, py_kwargs);
+    Py_DECREF (py_args);
+
+    if (cache->return_cache == NULL || cache->return_cache->is_skipped)
+        return ret;
+
+    if (ret != NULL && ret != Py_None) {
+        if (!PyTuple_Check (ret))
+            return ret;
+
+        if (PyTuple_GET_ITEM (ret, 0) != Py_None)
+            return ret;
+    }
+
+    PyErr_SetString (PyExc_TypeError, "constructor returned NULL");
+
+    Py_XDECREF (ret);
     return NULL;
 }
+
+PyGIFunctionCache *
+pygi_constructor_cache_new (GICallableInfo *info)
+{
+    PyGIConstructorCache *constructor_cache;
+    PyGIFunctionCache *function_cache;
+
+    constructor_cache = g_slice_new0 (PyGIConstructorCache);
+    function_cache = (PyGIFunctionCache *) constructor_cache;
+
+    function_cache->invoke = _constructor_cache_invoke_real;
+
+    if (!_function_cache_init (function_cache, info)) {
+        g_slice_free (PyGIConstructorCache, constructor_cache);
+        return NULL;
+    }
+
+    return function_cache;
+}
+
+/* PyGIFunctionWithInstanceCache */
+
+static gboolean
+_function_with_instance_cache_generate_args_cache_real (PyGICallableCache *callable_cache,
+                                                        GICallableInfo *callable_info)
+{
+    GIInterfaceInfo *interface_info;
+    PyGIArgCache *instance_cache;
+
+    interface_info = g_base_info_get_container ((GIBaseInfo *) callable_info);
+
+    instance_cache =
+        _arg_cache_new_for_interface (interface_info,
+                                      NULL,
+                                      NULL,
+                                      GI_TRANSFER_NOTHING,
+                                      PYGI_DIRECTION_FROM_PYTHON,
+                                      callable_cache);
+
+    g_base_info_unref ((GIBaseInfo *) interface_info);
+
+    if (instance_cache == NULL)
+        return FALSE;
+
+    /* Because we are not supplied a GITypeInfo for instance arguments,
+     * assume some defaults. */
+    instance_cache->is_pointer = TRUE;
+    instance_cache->py_arg_index = 0;
+    instance_cache->c_arg_index = 0;
+
+    _pygi_callable_cache_set_arg (callable_cache, 0, instance_cache);
+
+    callable_cache->n_py_args++;
+
+    return _callable_cache_generate_args_cache_real (callable_cache,
+                                                     callable_info);
+}
+
+static gboolean
+_function_with_instance_cache_init (PyGIFunctionWithInstanceCache *fwi_cache,
+                                    GICallableInfo *info)
+{
+    PyGICallableCache *callable_cache = (PyGICallableCache *) fwi_cache;
+
+    callable_cache->args_offset += 1;
+    callable_cache->generate_args_cache = _function_with_instance_cache_generate_args_cache_real;
+
+    return _function_cache_init ((PyGIFunctionCache *) fwi_cache, info);
+}
+
+/* PyGIMethodCache */
+
+PyGIFunctionCache *
+pygi_method_cache_new (GICallableInfo *info)
+{
+    PyGIMethodCache *method_cache;
+    PyGIFunctionWithInstanceCache *fwi_cache;
+
+    method_cache = g_slice_new0 (PyGIMethodCache);
+    fwi_cache = (PyGIFunctionWithInstanceCache *) method_cache;
+
+    if (!_function_with_instance_cache_init (fwi_cache, info)) {
+        g_slice_free (PyGIMethodCache, method_cache);
+        return NULL;
+    }
+
+    return (PyGIFunctionCache *) method_cache;
+}
+
+/* PyGIVFuncCache */
+
+static PyObject *
+_vfunc_cache_invoke_real (PyGIFunctionCache *function_cache,
+                          PyGIInvokeState *state,
+                          PyObject *py_args,
+                          PyObject *py_kwargs)
+{
+    PyGIVFuncCache *vfunc_cache = (PyGIVFuncCache *) function_cache;
+    PyObject *py_gtype;
+    GType implementor_gtype;
+    GError *error = NULL;
+    PyObject *ret;
+
+    py_gtype = PyTuple_GetItem (py_args, 0);
+    if (py_gtype == NULL) {
+        PyErr_SetString (PyExc_TypeError,
+                         "need the GType of the implementor class");
+        return FALSE;
+    }
+
+    implementor_gtype = pyg_type_from_object (py_gtype);
+    if (implementor_gtype == G_TYPE_INVALID)
+        return FALSE;
+
+    /* vfunc addresses are pulled into the state at call time and cannot be
+     * cached because the call site can specify a different portion of the
+     * class hierarchy. e.g. Object.do_func vs. SubObject.do_func might
+     * retrieve a different vfunc address but GI gives us the same vfunc info.
+     */
+    state->function_ptr = g_vfunc_info_get_address ((GIVFuncInfo *) vfunc_cache->info,
+                                                    implementor_gtype,
+                                                    &error);
+    if (pygi_error_check (&error)) {
+        return FALSE;
+    }
+
+    py_args = PyTuple_GetSlice (py_args, 1, PyTuple_Size (py_args));
+    ret = _function_cache_invoke_real (function_cache, state, py_args, py_kwargs);
+    Py_DECREF (py_args);
+
+    return ret;
+}
+
+static void
+_vfunc_cache_deinit_real (PyGICallableCache *callable_cache)
+{
+    PyGIVFuncCache *vfunc_cache = (PyGIVFuncCache *) callable_cache;
+
+    _function_cache_deinit_real (callable_cache);
+
+    g_base_info_unref (vfunc_cache->info);
+
+    g_slice_free (PyGIVFuncCache, vfunc_cache);
+}
+
+PyGIFunctionCache *
+pygi_vfunc_cache_new (GICallableInfo *info)
+{
+    PyGIVFuncCache *vfunc_cache;
+    PyGIFunctionCache *function_cache;
+    PyGIFunctionWithInstanceCache *fwi_cache;
+
+    vfunc_cache = g_slice_new0 (PyGIVFuncCache);
+    function_cache = (PyGIFunctionCache *) vfunc_cache;
+    fwi_cache = (PyGIFunctionWithInstanceCache *) vfunc_cache;
+
+    ((PyGICallableCache *) vfunc_cache)->deinit = _vfunc_cache_deinit_real;
+
+    /* This must be non-NULL for _function_cache_init() to create the
+     * invoker, the real address will be set in _vfunc_cache_invoke_real().
+     */
+    function_cache->invoker.native_address = (gpointer) 0xdeadbeef;
+
+    function_cache->invoke = _vfunc_cache_invoke_real;
+
+    if (!_function_with_instance_cache_init (fwi_cache, info)) {
+        g_slice_free (PyGIVFuncCache, vfunc_cache);
+        return NULL;
+    }
+
+    /* Required by _vfunc_cache_invoke_real() */
+    vfunc_cache->info = g_base_info_ref ((GIBaseInfo *) info);
+
+    return function_cache;
+}
diff --git a/gi/pygi-cache.h b/gi/pygi-cache.h
index cb8a2e7..fce13a0 100644
--- a/gi/pygi-cache.h
+++ b/gi/pygi-cache.h
@@ -29,8 +29,15 @@
 
 G_BEGIN_DECLS
 
-typedef struct _PyGICallableCache PyGICallableCache;
 typedef struct _PyGIArgCache PyGIArgCache;
+typedef struct _PyGICallableCache PyGICallableCache;
+typedef struct _PyGIFunctionCache PyGIFunctionCache;
+typedef struct _PyGIVFuncCache PyGIVFuncCache;
+
+typedef PyGIFunctionCache PyGICCallbackCache;
+typedef PyGIFunctionCache PyGIConstructorCache;
+typedef PyGIFunctionCache PyGIFunctionWithInstanceCache;
+typedef PyGIFunctionCache PyGIMethodCache;
 
 typedef gboolean (*PyGIMarshalFromPyFunc) (PyGIInvokeState   *state,
                                            PyGICallableCache *callable_cache,
@@ -70,21 +77,6 @@ typedef enum {
 } PyGIMetaArgType;
 
 /*
- * GI determines function types via a combination of flags and info classes.
- * Since for branching purposes they are mutually exclusive, the 
- * PyGIFunctionType enum consolidates them into one enumeration for ease of 
- * branching and debugging.
- */
-typedef enum {
-    PYGI_FUNCTION_TYPE_FUNCTION,
-    PYGI_FUNCTION_TYPE_METHOD,
-    PYGI_FUNCTION_TYPE_CONSTRUCTOR,
-    PYGI_FUNCTION_TYPE_VFUNC,
-    PYGI_FUNCTION_TYPE_CALLBACK,
-    PYGI_FUNCTION_TYPE_CCALLBACK,
- } PyGIFunctionType;
-
-/*
  * In PyGI IN and OUT arguments mean different things depending on the context
  * of the callable (e.g. is it a callback that is being called from C or a
  * function that is being called from python).  We don't as much care if the
@@ -97,6 +89,11 @@ typedef enum {
     PYGI_DIRECTION_BIDIRECTIONAL = PYGI_DIRECTION_TO_PYTHON | PYGI_DIRECTION_FROM_PYTHON
  } PyGIDirection;
 
+typedef enum {
+    PYGI_CALLING_CONTEXT_IS_FROM_C,
+    PYGI_CALLING_CONTEXT_IS_FROM_PY
+} PyGICallingContext;
+
 
 struct _PyGIArgCache
 {
@@ -159,7 +156,7 @@ struct _PyGICallableCache
 {
     const gchar *name;
 
-    PyGIFunctionType function_type;
+    PyGICallingContext calling_context;
 
     PyGIArgCache *return_cache;
     GPtrArray *args_cache;
@@ -171,6 +168,9 @@ struct _PyGICallableCache
     /* Index of user_data arg that can eat variable args passed to a callable. */
     gssize user_data_varargs_index;
 
+    /* Number of args already added */
+    gssize args_offset;
+
     /* Number of out args passed to g_function_info_invoke.
      * This is used for the length of PyGIInvokeState.out_values */
     gssize n_to_py_args;
@@ -188,10 +188,32 @@ struct _PyGICallableCache
      * This count does not include args with defaults. */
     gssize n_py_required_args;
 
-    /* An invoker with ffi_cif already setup */
-    GIFunctionInvoker invoker;
+    void     (*deinit)              (PyGICallableCache *callable_cache/*,
+                                     gboolean free*/);
+
+    gboolean (*generate_args_cache) (PyGICallableCache *callable_cache,
+                                     GICallableInfo *callable_info);
 };
 
+typedef struct _PyGIFunctionCache {
+    PyGICallableCache callable_cache;
+
+     /* An invoker with ffi_cif already setup */
+    GIFunctionInvoker invoker;
+
+    PyObject *(*invoke) (PyGIFunctionCache *function_cache,
+                         PyGIInvokeState *state,
+                         PyObject *py_args,
+                         PyObject *py_kwargs);
+} PyGIFunctionCache;
+
+typedef struct _PyGIVFuncCache {
+    PyGIFunctionWithInstanceCache fwi_cache;
+
+    GIBaseInfo *info;
+} PyGIVFuncCache;
+
+
 gboolean
 pygi_arg_base_setup      (PyGIArgCache *arg_cache,
                           GITypeInfo   *type_info,
@@ -238,12 +260,35 @@ void
 pygi_arg_cache_free      (PyGIArgCache *cache);
 
 void
-pygi_callable_cache_free (PyGICallableCache *cache);
+pygi_callable_cache_free    (PyGICallableCache *cache/*,
+                             gboolean free */);
+
+PyGIFunctionCache *
+pygi_function_cache_new     (GICallableInfo *info);
+
+PyObject *
+pygi_function_cache_invoke  (PyGIFunctionCache *function_cache,
+                             PyObject *py_args,
+                             PyObject *py_kwargs);
+
+PyGIFunctionCache *
+pygi_ccallback_cache_new    (GICallableInfo *info,
+                             GCallback function_ptr);
+
+PyObject *
+pygi_ccallback_cache_invoke (PyGIFunctionCache *function_cache,
+                             PyObject *py_args,
+                             PyObject *py_kwargs,
+                             gpointer user_data);
+
+PyGIFunctionCache *
+pygi_constructor_cache_new  (GICallableInfo *info);
+
+PyGIFunctionCache *
+pygi_method_cache_new       (GICallableInfo *info);
 
-PyGICallableCache *
-pygi_callable_cache_new  (GICallableInfo *callable_info,
-                          GCallback function_ptr,
-                          gboolean is_ccallback);
+PyGIFunctionCache *
+pygi_vfunc_cache_new        (GICallableInfo *info);
 
 #define _pygi_callable_cache_args_len(cache) ((cache)->args_cache)->len
 
diff --git a/gi/pygi-ccallback.c b/gi/pygi-ccallback.c
index 9f63ea0..8733b85 100644
--- a/gi/pygi-ccallback.c
+++ b/gi/pygi-ccallback.c
@@ -32,16 +32,16 @@ _ccallback_call(PyGICCallback *self, PyObject *args, PyObject *kwargs)
     PyObject *result;
 
     if (self->cache == NULL) {
-        self->cache = pygi_callable_cache_new (self->info, self->callback, TRUE);
+        self->cache = (PyGICCallbackCache *)pygi_ccallback_cache_new (self->info,
+                                                                      self->callback);
         if (self->cache == NULL)
             return NULL;
     }
 
-    result = pygi_callable_info_invoke( (GIBaseInfo *) self->info,
-                                         args,
-                                         kwargs,
-                                         self->cache,
-                                         self->user_data);
+    result = pygi_ccallback_cache_invoke (self->cache,
+                                          args,
+                                          kwargs,
+                                          self->user_data);
     return result;
 }
 
diff --git a/gi/pygi-closure.c b/gi/pygi-closure.c
index 42692e9..6da27b6 100644
--- a/gi/pygi-closure.c
+++ b/gi/pygi-closure.c
@@ -927,9 +927,7 @@ pygi_arg_callback_setup_from_info (PyGICallbackCache  *arg_cache,
     }
 
     if (callable_cache != NULL)
-        child_offset =
-            (callable_cache->function_type == PYGI_FUNCTION_TYPE_METHOD ||
-                 callable_cache->function_type == PYGI_FUNCTION_TYPE_VFUNC) ? 1: 0;
+        child_offset = callable_cache->args_offset;
 
     ( (PyGIArgCache *)arg_cache)->destroy_notify = (GDestroyNotify)_callback_cache_free_func;
 
diff --git a/gi/pygi-info.c b/gi/pygi-info.c
index 43ee711..fdf12b3 100644
--- a/gi/pygi-info.c
+++ b/gi/pygi-info.c
@@ -175,7 +175,8 @@ _base_info_dealloc (PyGIBaseInfo *self)
 
     g_base_info_unref (self->info);
 
-    pygi_callable_cache_free(self->cache);
+    if (self->cache != NULL)
+        pygi_callable_cache_free ( (PyGICallableCache *) self->cache);
 
     Py_TYPE( (PyObject *) self)->tp_free ( (PyObject *) self);
 }
diff --git a/gi/pygi-invoke-state-struct.h b/gi/pygi-invoke-state-struct.h
index 174f473..732f3b6 100644
--- a/gi/pygi-invoke-state-struct.h
+++ b/gi/pygi-invoke-state-struct.h
@@ -12,8 +12,6 @@ typedef struct _PyGIInvokeState
     PyObject *py_in_args;
     gssize n_py_in_args;
 
-    GType implementor_gtype;
-
     /* Number of arguments the ffi wrapped C function takes. Used as the exact
      * count for argument related arrays held in this struct.
      */
diff --git a/gi/pygi-invoke.c b/gi/pygi-invoke.c
index eebf959..eec00e1 100644
--- a/gi/pygi-invoke.c
+++ b/gi/pygi-invoke.c
@@ -25,16 +25,16 @@
 #include "pygi-marshal-cleanup.h"
 #include "pygi-error.h"
 
-static inline gboolean
-_invoke_callable (PyGIInvokeState *state,
-                  PyGICallableCache *cache,
-                  GICallableInfo *callable_info)
+gboolean
+pygi_invoke_callable (PyGIInvokeState *state,
+                      PyGIFunctionCache *function_cache)
 {
+    PyGICallableCache *cache = (PyGICallableCache *) function_cache;
     GIFFIReturnValue ffi_return_value = {0};
 
     Py_BEGIN_ALLOW_THREADS;
 
-        ffi_call (&cache->invoker.cif,
+        ffi_call (&function_cache->invoker.cif,
                   state->function_ptr,
                   (void *)&ffi_return_value,
                   (void **)state->args);
@@ -247,15 +247,14 @@ _py_args_combine_and_check_length (PyGICallableCache *cache,
     return combined_py_args;
 }
 
-static inline gboolean
-_invoke_state_init_from_callable_cache (GIBaseInfo *info,
-                                        PyGIInvokeState *state,
-                                        PyGICallableCache *cache,
-                                        PyObject *py_args,
-                                        PyObject *kwargs)
+gboolean
+pygi_invoke_state_init_from_cache (PyGIInvokeState *state,
+                                   PyGIFunctionCache *function_cache,
+                                   PyObject *py_args,
+                                   PyObject *kwargs)
 {
-    PyObject *combined_args = NULL;
-    state->implementor_gtype = 0;
+    PyGICallableCache *cache = (PyGICallableCache *) function_cache;
+
     state->n_args = _pygi_callable_cache_args_len (cache);
 
     if (cache->throws) {
@@ -263,74 +262,14 @@ _invoke_state_init_from_callable_cache (GIBaseInfo *info,
     }
 
     /* Copy the function pointer to the state for the normal case. For vfuncs,
-     * this will be filled out based on the implementor_gtype calculated below.
-     */
-    state->function_ptr = cache->invoker.native_address;
-
-    /* TODO: We don't use the class parameter sent in by  the structure
-     * so we remove it from the py_args tuple but we can keep it 
-     * around if we want to call actual gobject constructors
-     * in the future instead of calling g_object_new
+     * this has already been filled out based on the implementor's GType.
      */
-    if (cache->function_type == PYGI_FUNCTION_TYPE_CONSTRUCTOR) {
-        PyObject *constructor_class;
-        constructor_class = PyTuple_GetItem (py_args, 0);
-
-        if (constructor_class == NULL) {
-            PyErr_Clear ();
-            PyErr_Format (PyExc_TypeError,
-                          "Constructors require the class to be passed in as an argument, "
-                          "No arguments passed to the %s constructor.",
-                          cache->name);
-
-            return FALSE;
-        }
-    } else if (cache->function_type == PYGI_FUNCTION_TYPE_VFUNC) {
-        PyObject *py_gtype;
-        GError *error = NULL;
-
-        py_gtype = PyTuple_GetItem (py_args, 0);
-        if (py_gtype == NULL) {
-            PyErr_SetString (PyExc_TypeError,
-                             "need the GType of the implementor class");
-            return FALSE;
-        }
-
-        state->implementor_gtype = pyg_type_from_object (py_gtype);
-
-        if (state->implementor_gtype == 0)
-            return FALSE;
-
-        /* vfunc addresses are pulled into the state at call time and cannot be
-         * cached because the call site can specify a different portion of the
-         * class hierarchy. e.g. Object.do_func vs. SubObject.do_func might
-         * retrieve a different vfunc address but GI gives us the same vfunc info.
-         */
-        state->function_ptr = g_vfunc_info_get_address ((GIVFuncInfo *)info,
-                                                        state->implementor_gtype,
-                                                        &error);
-        if (pygi_error_check (&error)) {
-            return FALSE;
-        }
-    }
-
-    if  (cache->function_type == PYGI_FUNCTION_TYPE_CONSTRUCTOR ||
-            cache->function_type == PYGI_FUNCTION_TYPE_VFUNC) {
-
-        /* we could optimize this by using offsets instead of modifying the tuple but it makes the
-         * code more error prone and confusing so don't do that unless profiling shows
-         * significant gain
-         */
-        combined_args = PyTuple_GetSlice (py_args, 1, PyTuple_Size (py_args));
-    } else {
-        combined_args = py_args;
-        Py_INCREF (combined_args);
-    }
+    if (state->function_ptr == NULL)
+        state->function_ptr = function_cache->invoker.native_address;
 
     state->py_in_args = _py_args_combine_and_check_length (cache,
-                                                           combined_args,
+                                                           py_args,
                                                            kwargs);
-    Py_DECREF (combined_args);
 
     if (state->py_in_args == NULL) {
         return FALSE;
@@ -373,8 +312,8 @@ _invoke_state_init_from_callable_cache (GIBaseInfo *info,
     return TRUE;
 }
 
-static inline void
-_invoke_state_clear (PyGIInvokeState *state, PyGICallableCache *cache)
+void
+pygi_invoke_state_clear (PyGIInvokeState *state, PyGIFunctionCache *function_cache)
 {
     g_slice_free1 (state->n_args * sizeof(GIArgument *), state->args);
     g_slice_free1 (state->n_args * sizeof(gpointer), state->args_cleanup_data);
@@ -427,7 +366,7 @@ _caller_alloc (PyGIArgCache *arg_cache, GIArgument *arg)
     return TRUE;
 }
 
-/* _invoke_marshal_in_args:
+/* pygi_invoke_marshal_in_args:
  *
  * Fills out the state struct argument lists. arg_values will always hold
  * actual values marshaled either to or from Python and C. arg_pointers will
@@ -455,9 +394,10 @@ _caller_alloc (PyGIArgCache *arg_cache, GIArgument *arg)
  * ]]
  *
  */
-static inline gboolean
-_invoke_marshal_in_args (PyGIInvokeState *state, PyGICallableCache *cache)
+gboolean
+pygi_invoke_marshal_in_args (PyGIInvokeState *state, PyGIFunctionCache *function_cache)
 {
+    PyGICallableCache *cache = (PyGICallableCache *) function_cache;
     gssize i;
 
     if (state->n_py_in_args > cache->n_py_args) {
@@ -600,9 +540,10 @@ _invoke_marshal_in_args (PyGIInvokeState *state, PyGICallableCache *cache)
     return TRUE;
 }
 
-static inline PyObject *
-_invoke_marshal_out_args (PyGIInvokeState *state, PyGICallableCache *cache)
+PyObject *
+pygi_invoke_marshal_out_args (PyGIInvokeState *state, PyGIFunctionCache *function_cache)
 {
+    PyGICallableCache *cache = (PyGICallableCache *) function_cache;
     PyObject *py_out = NULL;
     PyObject *py_return = NULL;
     gssize total_out_args = cache->n_to_py_args;
@@ -610,15 +551,6 @@ _invoke_marshal_out_args (PyGIInvokeState *state, PyGICallableCache *cache)
 
     if (cache->return_cache) {
         if (!cache->return_cache->is_skipped) {
-            if (cache->function_type == PYGI_FUNCTION_TYPE_CONSTRUCTOR) {
-                if (state->return_arg.v_pointer == NULL) {
-                    PyErr_SetString (PyExc_TypeError, "constructor returned NULL");
-                    pygi_marshal_cleanup_args_return_fail (state,
-                                                       cache);
-                    return NULL;
-                }
-            }
-
             py_return = cache->return_cache->to_py_marshaller ( state,
                                                                 cache,
                                                                 cache->return_cache,
@@ -697,7 +629,7 @@ _invoke_marshal_out_args (PyGIInvokeState *state, PyGICallableCache *cache)
             if (py_obj == NULL) {
                 if (has_return)
                     py_arg_index--;
- 
+
                 pygi_marshal_cleanup_args_to_py_parameter_fail (state,
                                                                 cache,
                                                                 py_arg_index);
@@ -717,29 +649,8 @@ pygi_callable_info_invoke (GIBaseInfo *info, PyObject *py_args,
                            PyObject *kwargs, PyGICallableCache *cache,
                            gpointer user_data)
 {
-    PyGIInvokeState state = { 0, };
-    PyObject *ret = NULL;
-
-    if (!_invoke_state_init_from_callable_cache (info, &state, cache, py_args, kwargs))
-        goto err;
-
-    if (cache->function_type == PYGI_FUNCTION_TYPE_CCALLBACK)
-        state.user_data = user_data;
-
-    if (!_invoke_marshal_in_args (&state, cache))
-        goto err;
-
-    if (!_invoke_callable (&state, cache, info))
-        goto err;
-
-    ret = _invoke_marshal_out_args (&state, cache);
-    pygi_marshal_cleanup_args_from_py_marshal_success (&state, cache);
-
-    if (ret)
-        pygi_marshal_cleanup_args_to_py_marshal_success (&state, cache);
-err:
-    _invoke_state_clear (&state, cache);
-    return ret;
+    return pygi_function_cache_invoke ((PyGIFunctionCache *) cache,
+                                       py_args, kwargs);
 }
 
 PyObject *
@@ -747,7 +658,30 @@ _wrap_g_callable_info_invoke (PyGIBaseInfo *self, PyObject *py_args,
                               PyObject *kwargs)
 {
     if (self->cache == NULL) {
-        self->cache = pygi_callable_cache_new (self->info, NULL, FALSE);
+        PyGIFunctionCache *function_cache;
+        GIInfoType type = g_base_info_get_type (self->info);
+
+        if (type == GI_INFO_TYPE_FUNCTION) {
+            GIFunctionInfoFlags flags;
+
+            flags = g_function_info_get_flags ( (GIFunctionInfo *)self->info);
+
+            if (flags & GI_FUNCTION_IS_CONSTRUCTOR) {
+                function_cache = pygi_constructor_cache_new (self->info);
+            } else if (flags & GI_FUNCTION_IS_METHOD) {
+                function_cache = pygi_method_cache_new (self->info);
+            } else {
+                function_cache = pygi_function_cache_new (self->info);
+            }
+        } else if (type == GI_INFO_TYPE_VFUNC) {
+            function_cache = pygi_vfunc_cache_new (self->info);
+        } else if (type == GI_INFO_TYPE_CALLBACK) {
+            g_error ("Cannot invoke callback types");
+        } else {
+            function_cache = pygi_method_cache_new (self->info);
+        }
+
+        self->cache = (PyGICallableCache *)function_cache;
         if (self->cache == NULL)
             return NULL;
     }
diff --git a/gi/pygi-invoke.h b/gi/pygi-invoke.h
index b6bb4b9..7f22dec 100644
--- a/gi/pygi-invoke.h
+++ b/gi/pygi-invoke.h
@@ -26,8 +26,25 @@
 
 #include "pygi-private.h"
 #include "pygi-invoke-state-struct.h"
+
 G_BEGIN_DECLS
 
+gboolean  pygi_invoke_callable              (PyGIInvokeState *state,
+                                             PyGIFunctionCache *function_cache);
+
+gboolean  pygi_invoke_state_init_from_cache (PyGIInvokeState *state,
+                                             PyGIFunctionCache *function_cache,
+                                             PyObject *py_args,
+                                             PyObject *kwargs);
+
+void      pygi_invoke_state_clear           (PyGIInvokeState *state,
+                                             PyGIFunctionCache *function_cache);
+gboolean  pygi_invoke_marshal_in_args       (PyGIInvokeState *state,
+                                             PyGIFunctionCache *function_cache);
+PyObject *pygi_invoke_marshal_out_args      (PyGIInvokeState *state,
+                                             PyGIFunctionCache *function_cache);
+
+
 PyObject *pygi_callable_info_invoke (GIBaseInfo *info, PyObject *py_args,
                                      PyObject *kwargs, PyGICallableCache *cache,
                                      gpointer user_data);
diff --git a/gi/pygi.h b/gi/pygi.h
index 2a9ee14..3caf6f3 100644
--- a/gi/pygi.h
+++ b/gi/pygi.h
@@ -75,7 +75,7 @@ typedef struct {
     gpointer user_data;
     GIScopeType scope;
     GDestroyNotify destroy_notify_func;
-    PyGICallableCache *cache;
+    PyGICCallbackCache *cache;
 } PyGICCallback;
 
 
