Eo: Add a return value to eo_constructor().

From now on, constructors should return a value, usually the object
being worked on, or NULL (if the constructor failed). This can also
be used for implementing singletons, by just always returning the same
object from the constructor.

This is one of the final steps towards stabilizing Eo.

@feature

src/examples/eolian_cxx/colourable.c

@@ -26,7 +26,7 @@ struct _Colourable_Data
 
 typedef struct _Colourable_Data  Colourable_Data;
 
-void
+Eo *
 _colourable_eo_base_constructor(Eo *obj, Colourable_Data *self EINA_UNUSED)
 {
    if(!_colourable_impl_logdomain)
@@ -35,7 +35,7 @@ _colourable_eo_base_constructor(Eo *obj, Colourable_Data *self EINA_UNUSED)
           = eina_log_domain_register("colourable", EINA_COLOR_BLUE);
      }
    DBG("_colourable_constructor(%p, %p)\n", obj, MY_CLASS);
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 }
 
 void

src/examples/eolian_cxx/colourable_cxx.cc

@@ -19,12 +19,12 @@ extern "C"
 
 static efl::eina::log_domain domain("colourable");
 
-void
+Eo *
 _colourable_eo_base_constructor(Eo *obj, Colourable_Data *self)
 {
    EINA_CXX_DOM_LOG_DBG(domain) << __func__ << std::endl;
    self->r = self->g = self->b = 0;
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 }
 
 void

src/examples/eolian_cxx/colourable_stub.h

@@ -13,7 +13,7 @@ struct _Colourable_Data
 };
 typedef struct _Colourable_Data  Colourable_Data;
 
-void _colourable_eo_base_constructor(Eo *obj, Colourable_Data *self);
+Eo *_colourable_eo_base_constructor(Eo *obj, Colourable_Data *self);
 void _colourable_eo_base_destructor(Eo *obj, Colourable_Data *self);
 void _colourable_rgb_24bits_constructor(Eo *obj, Colourable_Data *self, int rgb);
 void _colourable_print_colour(Eo *obj, Colourable_Data *self);

src/lib/ecore_audio/ecore_audio_obj.c

@@ -54,12 +54,11 @@ _ecore_audio_volume_get(Eo *eo_obj EINA_UNUSED, Ecore_Audio_Object *obj)
   return obj->volume;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _ecore_audio_eo_base_constructor(Eo *eo_obj, Ecore_Audio_Object *obj)
 {
-  eo_do_super(eo_obj, MY_CLASS, eo_constructor());
-
   obj->volume = 1.0;
+  return eo_do_super_ret(eo_obj, MY_CLASS, eo_obj, eo_constructor());
 }
 
 #include "ecore_audio.eo.c"

src/lib/ecore_audio/ecore_audio_obj_in.c

@@ -170,12 +170,14 @@ _ecore_audio_in_ecore_audio_vio_set(Eo *eo_obj, Ecore_Audio_Input *obj, Ecore_Au
   obj->seekable = (vio->seek != NULL);
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _ecore_audio_in_eo_base_constructor(Eo *eo_obj, Ecore_Audio_Input *obj)
 {
-  eo_do_super(eo_obj, MY_CLASS, eo_constructor());
+  eo_obj = eo_do_super_ret(eo_obj, MY_CLASS, eo_obj, eo_constructor());
 
   obj->speed = 1.0;
+
+  return eo_obj;
 }
 
 EOLIAN static void

src/lib/ecore_audio/ecore_audio_obj_in_tone.c

@@ -107,12 +107,12 @@ _ecore_audio_in_tone_eo_base_key_data_get(Eo *eo_obj, Ecore_Audio_In_Tone_Data *
   }
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _ecore_audio_in_tone_eo_base_constructor(Eo *eo_obj, Ecore_Audio_In_Tone_Data *obj)
 {
   Ecore_Audio_Input *in_obj = eo_data_scope_get(eo_obj, ECORE_AUDIO_IN_CLASS);
 
-  eo_do_super(eo_obj, MY_CLASS, eo_constructor());
+  eo_obj = eo_do_super_ret(eo_obj, MY_CLASS, eo_obj, eo_constructor());
 
   in_obj->channels = 1;
   in_obj->samplerate = 44100;
@@ -120,6 +120,8 @@ _ecore_audio_in_tone_eo_base_constructor(Eo *eo_obj, Ecore_Audio_In_Tone_Data *o
   in_obj->seekable = EINA_TRUE;
 
   obj->freq = 1000;
+
+  return eo_obj;
 }
 
 #include "ecore_audio_in_tone.eo.c"

src/lib/ecore_audio/ecore_audio_obj_out.c

@@ -129,12 +129,14 @@ _ecore_audio_out_ecore_audio_vio_set(Eo *eo_obj, Ecore_Audio_Output *_pd EINA_UN
   ea_obj->vio->free_func = free_func;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _ecore_audio_out_eo_base_constructor(Eo *eo_obj, Ecore_Audio_Output *obj)
 {
-  eo_do_super(eo_obj, MY_CLASS, eo_constructor());
+  eo_obj = eo_do_super_ret(eo_obj, MY_CLASS, eo_obj, eo_constructor());
 
   obj->need_writer = EINA_TRUE;
+
+  return eo_obj;
 }
 
 EOLIAN static void

src/lib/ecore_audio/ecore_audio_obj_out_pulse.c

@@ -255,14 +255,14 @@ static void _state_job(void *data EINA_UNUSED)
    class_vars.state_job = NULL;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _ecore_audio_out_pulse_eo_base_constructor(Eo *eo_obj, Ecore_Audio_Out_Pulse_Data *_pd EINA_UNUSED)
 {
   int argc;
   char **argv;
   Ecore_Audio_Output *out_obj = eo_data_scope_get(eo_obj, ECORE_AUDIO_OUT_CLASS);
 
-  eo_do_super(eo_obj, MY_CLASS, eo_constructor());
+  eo_obj = eo_do_super_ret(eo_obj, MY_CLASS, eo_obj, eo_constructor());
 
   out_obj->need_writer = EINA_FALSE;
 
@@ -281,6 +281,8 @@ _ecore_audio_out_pulse_eo_base_constructor(Eo *eo_obj, Ecore_Audio_Out_Pulse_Dat
   class_vars.outputs = eina_list_append(class_vars.outputs, eo_obj);
   if (class_vars.state_job) eo_del(class_vars.state_job);
   class_vars.state_job = ecore_job_add(_state_job, NULL);
+
+  return eo_obj;
 }
 
 EOLIAN static void

src/lib/ecore_audio/ecore_audio_obj_out_sndfile.c

@@ -158,17 +158,18 @@ _ecore_audio_out_sndfile_ecore_audio_format_get(Eo *eo_obj, Ecore_Audio_Out_Sndf
   return obj->format;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _ecore_audio_out_sndfile_eo_base_constructor(Eo *eo_obj, Ecore_Audio_Out_Sndfile_Data *_pd EINA_UNUSED)
 {
   Ecore_Audio_Output *out_obj = eo_data_scope_get(eo_obj, ECORE_AUDIO_OUT_CLASS);
 
-  eo_do_super(eo_obj, MY_CLASS, eo_constructor());
+  eo_obj = eo_do_super_ret(eo_obj, MY_CLASS, eo_obj, eo_constructor());
 
   eo_do(eo_obj, ecore_audio_obj_format_set(ECORE_AUDIO_FORMAT_OGG));
 
   // FIXME: Use writer from output
   out_obj->need_writer = EINA_FALSE;
+  return eo_obj;
 }
 
 EOLIAN static void

src/lib/ecore_con/ecore_con.c

@@ -372,15 +372,17 @@ ecore_con_server_add(Ecore_Con_Type compl_type,
    return obj;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _ecore_con_server_eo_base_constructor(Ecore_Con_Server *obj, Ecore_Con_Server_Data *svr)
 {
-   eo_do_super(obj, ECORE_CON_SERVER_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, ECORE_CON_SERVER_CLASS, obj, eo_constructor());
 
    svr->fd = -1;
    svr->reject_excess_clients = EINA_FALSE;
    svr->client_limit = -1;
    svr->clients = NULL;
+
+   return obj;
 }
 
 EOLIAN static Eo *

src/lib/ecore_con/ecore_con_url.c

@@ -453,25 +453,26 @@ ecore_con_url_new(const char *url)
    return url_obj;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _efl_network_url_eo_base_constructor(Efl_Network_Url *url_obj, Efl_Network_Url_Data *url_con EINA_UNUSED)
 {
-   eo_do_super(url_obj, MY_CLASS, eo_constructor());
+   url_obj = eo_do_super_ret(url_obj, MY_CLASS, url_obj, eo_constructor());
 
    if (!_init_count) eo_error_set(url_obj);
    if (!_c_init())
      {
         eo_error_set(url_obj);
-        return;
+        return NULL;
      }
 
    url_con->curl_easy = _c->curl_easy_init();
    if (!url_con->curl_easy)
      {
         eo_error_set(url_obj);
-        return;
+        return NULL;
      }
 
+   return url_obj;
 }
 
 EOLIAN static Eo *

src/lib/ector/cairo/ector_cairo_surface.c

@@ -121,14 +121,16 @@ _ector_cairo_surface_ector_generic_surface_reference_point_set(Eo *obj EINA_UNUS
    pd->current.y = y;
 }
 
-static void
+static Eo *
 _ector_cairo_surface_eo_base_constructor(Eo *obj,
                                          Ector_Cairo_Surface_Data *pd)
 {
-   eo_do_super(obj, ECTOR_CAIRO_SURFACE_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, ECTOR_CAIRO_SURFACE_CLASS, obj, eo_constructor());
    _cairo_count++;
 
    _ector_cairo_surface_context_set(obj, pd, NULL);
+
+   return obj;
 }
 
 static void

src/lib/ector/cairo/ector_renderer_cairo_base.c

@@ -190,16 +190,18 @@ _ector_renderer_cairo_base_ector_renderer_generic_base_draw(Eo *obj,
    return EINA_TRUE;
 }
 
-static void
+static Eo *
 _ector_renderer_cairo_base_eo_base_constructor(Eo *obj, Ector_Renderer_Cairo_Base_Data *pd EINA_UNUSED)
 {
-   eo_do_super(obj, ECTOR_RENDERER_CAIRO_BASE_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, ECTOR_RENDERER_CAIRO_BASE_CLASS, obj, eo_constructor());
 
    pd->generic = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS, obj);
 
-   USE(obj, cairo_matrix_init_identity, );
+   USE(obj, cairo_matrix_init_identity, NULL);
 
    cairo_matrix_init_identity(&identity);
+
+   return obj;
 }
 
 static void

src/lib/ector/cairo/ector_renderer_cairo_shape.c

@@ -244,15 +244,17 @@ _ector_renderer_cairo_shape_ector_renderer_generic_base_bounds_get(Eo *obj,
    r->y += bd->generic->origin.y;
 }
 
-void
+Eo *
 _ector_renderer_cairo_shape_eo_base_constructor(Eo *obj, Ector_Renderer_Cairo_Shape_Data *pd)
 {
-   eo_do_super(obj, ECTOR_RENDERER_CAIRO_SHAPE_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, ECTOR_RENDERER_CAIRO_SHAPE_CLASS, obj, eo_constructor());
    pd->shape = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_SHAPE_MIXIN, obj);
    pd->base = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS, obj);
 
    eo_do(obj,
          eo_event_callback_add(EFL_GFX_PATH_CHANGED, _ector_renderer_cairo_shape_path_changed, pd));
+
+   return obj;
 }
 
 void

src/lib/ector/software/ector_renderer_software_gradient_linear.c

@@ -71,13 +71,15 @@ _ector_renderer_software_gradient_linear_ector_renderer_software_base_fill(Eo *o
    return EINA_TRUE;
 }
 
-void
+Eo *
 _ector_renderer_software_gradient_linear_eo_base_constructor(Eo *obj,
                                                              Ector_Renderer_Software_Gradient_Data *pd)
 {
-   eo_do_super(obj, ECTOR_RENDERER_SOFTWARE_GRADIENT_LINEAR_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, ECTOR_RENDERER_SOFTWARE_GRADIENT_LINEAR_CLASS, obj, eo_constructor());
    pd->gd  = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_GRADIENT_MIXIN, obj);
    pd->gld = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_GRADIENT_LINEAR_MIXIN, obj);
+
+   return obj;
 }
 
 void

src/lib/ector/software/ector_renderer_software_gradient_radial.c

@@ -79,13 +79,15 @@ _ector_renderer_software_gradient_radial_ector_renderer_software_base_fill(Eo *o
    return EINA_TRUE;
 }
 
-void
+Eo *
 _ector_renderer_software_gradient_radial_eo_base_constructor(Eo *obj,
                                                              Ector_Renderer_Software_Gradient_Data *pd)
 {
-   eo_do_super(obj, ECTOR_RENDERER_SOFTWARE_GRADIENT_RADIAL_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, ECTOR_RENDERER_SOFTWARE_GRADIENT_RADIAL_CLASS, obj, eo_constructor());
    pd->gd  = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_GRADIENT_MIXIN, obj);
    pd->gld = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_GRADIENT_RADIAL_MIXIN, obj);
+
+   return obj;
 }
 
 void

src/lib/ector/software/ector_renderer_software_shape.c

@@ -362,14 +362,16 @@ _ector_renderer_software_shape_path_changed(void *data, Eo *obj EINA_UNUSED, con
    return EINA_TRUE;
 }
 
-void
+Eo *
 _ector_renderer_software_shape_eo_base_constructor(Eo *obj, Ector_Renderer_Software_Shape_Data *pd)
 {
-   eo_do_super(obj, ECTOR_RENDERER_SOFTWARE_SHAPE_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, ECTOR_RENDERER_SOFTWARE_SHAPE_CLASS, obj, eo_constructor());
    pd->shape = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_SHAPE_MIXIN, obj);
    pd->base = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS, obj);
    eo_do(obj,
          eo_event_callback_add(EFL_GFX_PATH_CHANGED, _ector_renderer_software_shape_path_changed, pd));
+
+   return obj;
 }
 
 void

src/lib/ector/software/ector_software_surface.c

@@ -65,17 +65,19 @@ _ector_software_surface_surface_get(Eo *obj EINA_UNUSED,
    *height = pd->software->fill_data.raster_buffer.height;
 }
 
-static void
+static Eo *
 _ector_software_surface_eo_base_constructor(Eo *obj,
                                             Ector_Software_Surface_Data *pd EINA_UNUSED)
 {
-  eo_do_super(obj, ECTOR_SOFTWARE_SURFACE_CLASS, eo_constructor());
+  obj = eo_do_super_ret(obj, ECTOR_SOFTWARE_SURFACE_CLASS, obj, eo_constructor());
   if(_software_count == 0)
     {
        pd->software = (Software_Rasterizer *) calloc(1, sizeof(Software_Rasterizer));
        ector_software_rasterizer_init(pd->software);
     }
   _software_count++;
+
+  return obj;
 }
 
 static void

src/lib/edje/edje_edit.c

@@ -239,12 +239,12 @@ edje_edit_object_add(Evas *evas)
    return e;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _edje_edit_eo_base_constructor(Eo *obj, Edje_Edit *eed)
 {
    eed->base = eo_data_ref(obj, EDJE_OBJECT_CLASS);
 
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 }
 
 EOLIAN static void

src/lib/edje/edje_smart.c

@@ -24,14 +24,16 @@ edje_object_add(Evas *evas)
    return e;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _edje_object_eo_base_constructor(Eo *obj, Edje *ed)
 {
    ed->base = eo_data_ref(obj, EVAS_SMART_CLIPPED_CLASS);
 
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
    eo_do(obj, evas_obj_type_set(MY_CLASS_NAME_LEGACY));
    _edje_lib_ref();
+
+   return obj;
 }
 
 EOLIAN static void

src/lib/eio/eio_model.c

@@ -623,15 +623,15 @@ _eio_model_efl_model_base_children_slice_get(Eo *obj EINA_UNUSED, Eio_Model_Data
 /**
  * Class definitions
  */
-static void
+static Eo *
 _eio_model_eo_base_constructor(Eo *obj, Eio_Model_Data *priv)
 {
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
    unsigned int i;
    priv->obj = obj;
 
    priv->properties_name = eina_array_new(EIO_MODEL_PROP_LAST);
-   EINA_SAFETY_ON_NULL_RETURN(priv->properties_name);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(priv->properties_name, NULL);
    for (i = 0; i < EIO_MODEL_PROP_LAST; ++i)
      eina_array_push(priv->properties_name, _eio_model_prop_names[i]);
 
@@ -645,6 +645,8 @@ _eio_model_eo_base_constructor(Eo *obj, Eio_Model_Data *priv)
    priv->load.status = EFL_MODEL_LOAD_STATUS_UNLOADED;
    priv->monitor = NULL;
    eina_spinlock_new(&priv->filter_lock);
+
+   return obj;
 }
 
 static void

src/lib/emotion/emotion_smart.c

@@ -263,11 +263,13 @@ emotion_object_add(Evas *evas)
    return e;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _emotion_object_eo_base_constructor(Eo *obj, Emotion_Object_Data *pd EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
    eo_do(obj, evas_obj_type_set(E_OBJ_NAME));
+
+   return obj;
 }
 
 EAPI Evas_Object *

src/lib/eo/Eo.h

@@ -639,8 +639,8 @@ EAPI void eo_error_set_internal(const Eo *obj, const char *file, int line);
 #define _eo_add_common(klass, parent, is_ref, ...) \
    ( \
      _eo_do_start(_eo_add_internal_start(__FILE__, __LINE__, klass, parent, is_ref), \
-        klass, EINA_FALSE, __FILE__, __FUNCTION__, __LINE__), \
+        klass, EINA_FALSE, __FILE__, __FUNCTION__, __LINE__) \
-     eo_constructor(), ##__VA_ARGS__, \
+     , ##__VA_ARGS__, \
      (Eo *) _eo_add_end() \
    )
 

src/lib/eo/eo.c

@@ -920,6 +920,18 @@ _eo_add_internal_start(const char *file, int line, const Eo_Class *klass_id, Eo
           }
      }
 
+   /* eo_id can change here. Freeing is done on the resolved object. */
+   eo_do(eo_id, eo_id = eo_constructor());
+   if (!eo_id)
+     {
+        ERR("Object of class '%s' - Error while constructing object",
+            klass->desc->name);
+        /* Unref twice, once for the ref in _eo_add_internal_start, and once for the basic object ref. */
+        _eo_unref(obj);
+        _eo_unref(obj);
+        return NULL;
+     }
+
    return eo_id;
 }
 

src/lib/eo/eo_base.eo

@@ -45,6 +45,7 @@ Return event freeze count. */
       constructor {
          /*@ Call the object's constructor.
 Should not be used with #eo_do. Only use it with #eo_do_super. */
+         return: Eo *; /*@ The new object created, can be NULL if aborting */
       }
       destructor {
          /*@ Call the object's destructor.

src/lib/eo/eo_base_class.c

@@ -967,12 +967,14 @@ EAPI const Eina_Value_Type *EO_DBG_INFO_TYPE = &_EO_DBG_INFO_TYPE;
 /* EO_BASE_CLASS stuff */
 #define MY_CLASS EO_BASE_CLASS
 
-EOLIAN static void
+EOLIAN static Eo *
 _eo_base_constructor(Eo *obj, Eo_Base_Data *pd EINA_UNUSED)
 {
    DBG("%p - %s.", obj, eo_class_name_get(MY_CLASS));
 
    _eo_condtor_done(obj);
+
+   return obj;
 }
 
 EOLIAN static void

src/lib/evas/canvas/evas_3d_camera.c

@@ -62,12 +62,14 @@ evas_3d_camera_node_del(Evas_3D_Camera *camera, Evas_3D_Node *node)
    else eina_hash_set(pd->nodes, &node, (const void *)(uintptr_t)(count - 1));
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_3d_camera_eo_base_constructor(Eo *obj,
                                        Evas_3D_Camera_Data *pd EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
    eo_do(obj, evas_3d_object_type_set(EVAS_3D_OBJECT_TYPE_CAMERA));
+
+   return obj;
 }
 
 EOLIAN static void

src/lib/evas/canvas/evas_3d_light.c

@@ -76,10 +76,10 @@ evas_3d_light_add(Evas *e)
    return eo_obj;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_3d_light_eo_base_constructor(Eo *obj, Evas_3D_Light_Data *pd)
 {
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
    eo_do(obj, evas_3d_object_type_set(EVAS_3D_OBJECT_TYPE_LIGHT));
    evas_color_set(&pd->ambient, 0.0, 0.0, 0.0, 1.0);
    evas_color_set(&pd->diffuse, 1.0, 1.0, 1.0, 1.0);
@@ -92,6 +92,8 @@ _evas_3d_light_eo_base_constructor(Eo *obj, Evas_3D_Light_Data *pd)
    pd->atten_const = 1.0;
    pd->atten_linear = 0.0;
    pd->atten_quad = 0.0;
+
+   return obj;
 }
 
 EOLIAN static void

src/lib/evas/canvas/evas_3d_material.c

@@ -88,10 +88,10 @@ evas_3d_material_add(Evas *e)
    return eo_obj;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_3d_material_eo_base_constructor(Eo *obj EINA_UNUSED, Evas_3D_Material_Data *pd)
 {
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
    eo_do(obj, evas_3d_object_type_set(EVAS_3D_OBJECT_TYPE_MATERIAL));
 
    evas_color_set(&pd->attribs[EVAS_3D_MATERIAL_AMBIENT].color, 0.2, 0.2, 0.2, 1.0);
@@ -99,6 +99,8 @@ _evas_3d_material_eo_base_constructor(Eo *obj EINA_UNUSED, Evas_3D_Material_Data
    evas_color_set(&pd->attribs[EVAS_3D_MATERIAL_SPECULAR].color, 1.0, 1.0, 1.0, 1.0);
    evas_color_set(&pd->attribs[EVAS_3D_MATERIAL_EMISSION].color, 0.0, 0.0, 0.0, 1.0);
    pd->shininess = 150.0;
+
+   return obj;
 }
 
 EOLIAN static void

src/lib/evas/canvas/evas_3d_mesh.c

@@ -252,12 +252,14 @@ evas_3d_mesh_add(Evas *e)
    return eo_obj;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_3d_mesh_eo_base_constructor(Eo *obj, Evas_3D_Mesh_Data *pd)
 {
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
    eo_do (obj, evas_3d_object_type_set(EVAS_3D_OBJECT_TYPE_MESH));
    _mesh_init(pd);
+
+   return obj;
 }
 
 EOLIAN static void

src/lib/evas/canvas/evas_3d_object.c

@@ -3,15 +3,17 @@
 
 #define MY_CLASS EVAS_3D_OBJECT_CLASS
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_3d_object_eo_base_constructor(Eo *obj, Evas_3D_Object_Data *pd)
 {
    Eo *e = NULL;
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
    eo_do(obj, e = eo_parent_get());
    pd->evas = e;
    pd->type = EVAS_3D_OBJECT_TYPE_INVALID;
    memset(&pd->dirty[0], 0x00, sizeof(Eina_Bool) * EVAS_3D_STATE_MAX);
+
+   return obj;
 }
 
 EOLIAN static Evas *

src/lib/evas/canvas/evas_3d_scene.c

@@ -64,16 +64,18 @@ evas_3d_scene_add(Evas *e)
    return eo_obj;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_3d_scene_eo_base_constructor(Eo *obj, Evas_3D_Scene_Data *pd)
 {
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
    eo_do(obj, evas_3d_object_type_set(EVAS_3D_OBJECT_TYPE_SCENE));
    evas_color_set(&pd->bg_color, 0.0, 0.0, 0.0, 0.0);
    pd->shadows_enabled = EINA_FALSE;
    pd->color_pick_enabled = EINA_FALSE;
    pd->node_mesh_colors = NULL;
    pd->colors_node_mesh = NULL;
+
+   return obj;
 }
 
 EOLIAN static void

src/lib/evas/canvas/evas_3d_texture.c

@@ -319,13 +319,15 @@ evas_3d_texture_add(Evas *e)
 }
 
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_3d_texture_eo_base_constructor(Eo *obj, Evas_3D_Texture_Data *pd EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
    pd->atlas_enable = EINA_TRUE;
 
    eo_do(obj, evas_3d_object_type_set(EVAS_3D_OBJECT_TYPE_TEXTURE));
+
+   return obj;
 }
 
 EOLIAN static void

src/lib/evas/canvas/evas_main.c

@@ -148,10 +148,10 @@ evas_new(void)
    return eo_obj;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_canvas_eo_base_constructor(Eo *eo_obj, Evas_Public_Data *e)
 {
-   eo_do_super(eo_obj, MY_CLASS, eo_constructor());
+   eo_obj = eo_do_super_ret(eo_obj, MY_CLASS, eo_obj, eo_constructor());
 
    e->evas = eo_obj;
    e->output.render_method = RENDER_METHOD_INVALID;
@@ -185,6 +185,8 @@ _evas_canvas_eo_base_constructor(Eo *eo_obj, Evas_Public_Data *e)
 
 #undef EVAS_ARRAY_SET
    eina_lock_new(&(e->lock_objects));
+
+   return eo_obj;
 }
 
 EAPI void

src/lib/evas/canvas/evas_object_box.c

@@ -462,13 +462,15 @@ evas_object_box_add(Evas *evas)
    return obj;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_box_eo_base_constructor(Eo *obj, Evas_Object_Box_Data *class_data EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
    eo_do(obj,
          evas_obj_smart_callbacks_descriptions_set(_signals),
          evas_obj_type_set(MY_CLASS_NAME_LEGACY));
+
+   return obj;
 }
 
 EOLIAN static Evas_Object*

src/lib/evas/canvas/evas_object_grid.c

@@ -269,12 +269,13 @@ evas_object_grid_add(Evas *evas)
    return obj;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_grid_eo_base_constructor(Eo *obj, Evas_Grid_Data *class_data EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
    eo_do(obj, evas_obj_smart_attach(_evas_object_grid_smart_class_new()));
 
+   return obj;
 //   return evas_object_smart_add(evas, _evas_object_grid_smart_class_new());
 }
 

src/lib/evas/canvas/evas_object_image.c

@@ -342,7 +342,7 @@ _init_cow(Eo *eo_obj)
    return EINA_TRUE;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_image_eo_base_constructor(Eo *eo_obj, Evas_Image_Data *o)
 {
    Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
@@ -350,7 +350,7 @@ _evas_image_eo_base_constructor(Eo *eo_obj, Evas_Image_Data *o)
    Eo *parent = NULL;
    Evas_Colorspace cspace;
 
-   eo_do_super(eo_obj, MY_CLASS, eo_constructor());
+   eo_obj = eo_do_super_ret(eo_obj, MY_CLASS, eo_obj, eo_constructor());
 
    eo_do(eo_obj, parent = eo_parent_get());
    eo_e = evas_object_evas_get(parent);
@@ -359,7 +359,7 @@ _evas_image_eo_base_constructor(Eo *eo_obj, Evas_Image_Data *o)
    evas_object_inject(eo_obj, obj, eo_e);
 
    if (!_init_cow(eo_obj))
-     return;
+     return NULL;
 
    o->load_opts = eina_cow_alloc(evas_object_image_load_opts_cow);
    o->pixels = eina_cow_alloc(evas_object_image_pixels_cow);
@@ -377,6 +377,8 @@ _evas_image_eo_base_constructor(Eo *eo_obj, Evas_Image_Data *o)
             state_write->filter = eina_cow_alloc(evas_object_filter_cow);
         EINA_COW_IMAGE_STATE_WRITE_END(o, state_write);
      }
+
+   return eo_obj;
 }
 
 EAPI Evas_Object *

src/lib/evas/canvas/evas_object_line.c

@@ -214,14 +214,14 @@ evas_object_line_init(Evas_Object *eo_obj)
    obj->type = o_type;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_line_eo_base_constructor(Eo *eo_obj, Evas_Line_Data *class_data EINA_UNUSED)
 {
    Evas_Object_Protected_Data *obj;
    Evas_Line_Data *o;
    Eo *parent = NULL;
 
-   eo_do_super(eo_obj, MY_CLASS, eo_constructor());
+   eo_obj = eo_do_super_ret(eo_obj, MY_CLASS, eo_obj, eo_constructor());
 
    obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
    evas_object_line_init(eo_obj);
@@ -235,6 +235,8 @@ _evas_line_eo_base_constructor(Eo *eo_obj, Evas_Line_Data *class_data EINA_UNUSE
    o->cur.x2 = 31;
    o->cur.y2 = 31;
    o->prev = o->cur;
+
+   return eo_obj;
 }
 
 static void

src/lib/evas/canvas/evas_object_main.c

@@ -82,12 +82,12 @@ _init_cow(void)
    return EINA_TRUE;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_object_eo_base_constructor(Eo *eo_obj, Evas_Object_Protected_Data *obj)
 {
    Eo *parent = NULL;
 
-   eo_do_super(eo_obj, MY_CLASS, eo_constructor());
+   eo_obj = eo_do_super_ret(eo_obj, MY_CLASS, eo_obj, eo_constructor());
    eo_do(eo_obj, evas_obj_type_set(MY_CLASS_NAME));
    eo_manual_free_set(eo_obj, EINA_TRUE);
 
@@ -96,7 +96,7 @@ _evas_object_eo_base_constructor(Eo *eo_obj, Evas_Object_Protected_Data *obj)
    if (!obj || !_init_cow() || !eo_isa(parent, EVAS_COMMON_INTERFACE_INTERFACE))
      {
         eo_error_set(eo_obj);
-        return;
+        return NULL;
      }
 
    obj->is_frame = EINA_FALSE;
@@ -107,6 +107,8 @@ _evas_object_eo_base_constructor(Eo *eo_obj, Evas_Object_Protected_Data *obj)
    obj->prev = eina_cow_alloc(evas_object_state_cow);
    obj->data_3d = eina_cow_alloc(evas_object_3d_cow);
    obj->mask = eina_cow_alloc(evas_object_mask_cow);
+
+   return eo_obj;
 }
 
 void

src/lib/evas/canvas/evas_object_polygon.c

@@ -101,18 +101,20 @@ evas_object_polygon_add(Evas *e)
    return eo_obj;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_polygon_eo_base_constructor(Eo *eo_obj, Evas_Polygon_Data *class_data EINA_UNUSED)
 {
    Evas_Object_Protected_Data *obj;
    Eo *parent = NULL;
 
-   eo_do_super(eo_obj, MY_CLASS, eo_constructor());
+   eo_obj = eo_do_super_ret(eo_obj, MY_CLASS, eo_obj, eo_constructor());
 
    obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
    evas_object_polygon_init(eo_obj);
    eo_do(eo_obj, parent = eo_parent_get());
    evas_object_inject(eo_obj, obj, evas_object_evas_get(parent));
+
+   return eo_obj;
 }
 
 EOLIAN static void

src/lib/evas/canvas/evas_object_rectangle.c

@@ -89,18 +89,20 @@ evas_object_rectangle_add(Evas *e)
    return eo_obj;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_rectangle_eo_base_constructor(Eo *eo_obj, Evas_Rectangle_Data *class_data EINA_UNUSED)
 {
    Eo *parent = NULL;
 
-   eo_do_super(eo_obj, MY_CLASS, eo_constructor());
+   eo_obj = eo_do_super_ret(eo_obj, MY_CLASS, eo_obj, eo_constructor());
 
    Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
    evas_object_rectangle_init(eo_obj);
 
    eo_do(eo_obj, parent = eo_parent_get());
    evas_object_inject(eo_obj, obj, evas_object_evas_get(parent));
+
+   return eo_obj;
 }
 
 /* all nice and private */

src/lib/evas/canvas/evas_object_smart.c

@@ -545,7 +545,7 @@ evas_object_smart_add(Evas *eo_e, Evas_Smart *s)
    return eo_obj;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_object_smart_eo_base_constructor(Eo *eo_obj, Evas_Smart_Data *class_data EINA_UNUSED)
 {
    Evas_Object_Protected_Data *obj;
@@ -555,7 +555,7 @@ _evas_object_smart_eo_base_constructor(Eo *eo_obj, Evas_Smart_Data *class_data E
    smart = class_data;
    smart->object = eo_obj;
 
-   eo_do_super(eo_obj, MY_CLASS, eo_constructor());
+   eo_obj = eo_do_super_ret(eo_obj, MY_CLASS, eo_obj, eo_constructor());
    evas_object_smart_init(eo_obj);
 
    obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
@@ -564,6 +564,8 @@ _evas_object_smart_eo_base_constructor(Eo *eo_obj, Evas_Smart_Data *class_data E
    eo_do(eo_obj,
          evas_obj_type_set(MY_CLASS_NAME_LEGACY),
          evas_obj_smart_add());
+
+   return eo_obj;
 }
 
 EOLIAN static void

src/lib/evas/canvas/evas_object_smart_clipped.c

@@ -250,10 +250,10 @@ evas_object_smart_clipped_class_get(void)
    return class;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
-_evas_smart_clipped_eo_base_constructor(Eo *eo_obj, Evas_Object_Smart_Clipped_Data *class_data EINA_UNUSED)
+_evas_smart_clipped_eo_base_constructor(Eo *obj, Evas_Object_Smart_Clipped_Data *class_data EINA_UNUSED)
 {
-   eo_do_super(eo_obj, MY_CLASS, eo_constructor());
+   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 }
 
 #include "canvas/evas_smart_clipped.eo.c"

src/lib/evas/canvas/evas_object_table.c

@@ -966,11 +966,13 @@ evas_object_table_add(Evas *evas)
    return obj;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_table_eo_base_constructor(Eo *obj, Evas_Table_Data *class_data EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
    eo_do(obj, evas_obj_type_set(MY_CLASS_NAME_LEGACY));
+
+   return obj;
 }
 
 EOLIAN static Evas_Object*

src/lib/evas/canvas/evas_object_text.c

@@ -365,10 +365,10 @@ evas_object_text_add(Evas *e)
    return eo_obj;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_text_eo_base_constructor(Eo *eo_obj, Evas_Text_Data *o)
 {
-   eo_do_super(eo_obj, MY_CLASS, eo_constructor());
+   eo_obj = eo_do_super_ret(eo_obj, MY_CLASS, eo_obj, eo_constructor());
    evas_object_text_init(eo_obj);
    Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
    Eo *parent = NULL;
@@ -377,6 +377,8 @@ _evas_text_eo_base_constructor(Eo *eo_obj, Evas_Text_Data *o)
    evas_object_inject(eo_obj, obj, evas_object_evas_get(parent));
 
    o->cur.filter = eina_cow_alloc(evas_object_filter_cow);
+
+   return eo_obj;
 }
 
 EOLIAN static void

src/lib/evas/canvas/evas_object_textblock.c

@@ -5782,14 +5782,14 @@ evas_object_textblock_add(Evas *e)
    return eo_obj;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_textblock_eo_base_constructor(Eo *eo_obj, Evas_Textblock_Data *class_data EINA_UNUSED)
 {
    Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
    Evas_Textblock_Data *o;
    Eo *eo_parent = NULL;
 
-   eo_do_super(eo_obj, MY_CLASS, eo_constructor());
+   eo_obj = eo_do_super_ret(eo_obj, MY_CLASS, eo_obj, eo_constructor());
 
    /* set up methods (compulsory) */
    obj->func = &object_func;
@@ -5803,6 +5803,8 @@ _evas_textblock_eo_base_constructor(Eo *eo_obj, Evas_Textblock_Data *class_data
 
    eo_do(eo_obj, eo_parent = eo_parent_get());
    evas_object_inject(eo_obj, obj, evas_object_evas_get(eo_parent));
+
+   return eo_obj;
 }
 
 EAPI Evas_Textblock_Style *

src/lib/evas/canvas/evas_object_textgrid.c

@@ -1061,18 +1061,20 @@ evas_object_textgrid_add(Evas *e)
    return eo_obj;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_textgrid_eo_base_constructor(Eo *eo_obj, Evas_Textgrid_Data *class_data EINA_UNUSED)
 {
    Eo *eo_parent = NULL;
 
-   eo_do_super(eo_obj, MY_CLASS, eo_constructor());
+   eo_obj = eo_do_super_ret(eo_obj, MY_CLASS, eo_obj, eo_constructor());
 
    Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
    evas_object_textgrid_init(eo_obj);
 
    eo_do(eo_obj, eo_parent = eo_parent_get());
    evas_object_inject(eo_obj, obj, evas_object_evas_get(eo_parent));
+
+   return eo_obj;
 }
 
 EOLIAN static void

src/lib/evas/canvas/evas_object_vg.c

@@ -98,13 +98,13 @@ _evas_vg_eo_base_destructor(Eo *eo_obj, Evas_VG_Data *pd)
    eo_do_super(eo_obj, MY_CLASS, eo_destructor());
 }
 
-void
+Eo *
 _evas_vg_eo_base_constructor(Eo *eo_obj, Evas_VG_Data *pd)
 {
    Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
    Eo *parent = NULL;
 
-   eo_do_super(eo_obj, MY_CLASS, eo_constructor());
+   eo_obj = eo_do_super_ret(eo_obj, MY_CLASS, eo_obj, eo_constructor());
 
    /* set up methods (compulsory) */
    obj->func = &object_func;
@@ -117,6 +117,8 @@ _evas_vg_eo_base_constructor(Eo *eo_obj, Evas_VG_Data *pd)
 
    eo_do(eo_obj, parent = eo_parent_get());
    evas_object_inject(eo_obj, obj, evas_object_evas_get(parent));
+
+   return eo_obj;
 }
 
 static void

src/lib/evas/canvas/evas_out.c

@@ -23,7 +23,7 @@ evas_out_add(Evas *e)
    return eo_obj;
 }
 
-EOLIAN static void
+EOLIAN static Eo *
 _evas_out_eo_base_constructor(Eo *eo_obj, Evas_Out_Data *eo_dat)
 {
    Eo *eo_parent = NULL;
@@ -33,14 +33,16 @@ _evas_out_eo_base_constructor(Eo *eo_obj, Evas_Out_Data *eo_dat)
    e = eo_data_scope_get(eo_parent, EVAS_CANVAS_CLASS);
    evas_canvas_async_block(e);
 
-   eo_do_super(eo_obj, MY_CLASS, eo_constructor());
+   eo_obj = eo_do_super_ret(eo_obj, MY_CLASS, eo_obj, eo_constructor());
 
-   if (!e) return;
+   if (!e) return NULL;
    e->outputs = eina_list_append(e->outputs, eo_obj);
    if (e->engine.func->info) eo_dat->info = e->engine.func->info(eo_parent);
    // XXX: context and output are currently held in the core engine and are
    // allocated by engine specific internal code. this all needs a new engine
    // api to make it work
+
+   return eo_obj;
 }
 
 EAPI void

src/lib/evas/canvas/evas_vg_container.c

@@ -25,17 +25,19 @@ _efl_vg_container_render_pre(Eo *obj EINA_UNUSED,
      _evas_vg_render_pre(child, s, current);
 }
 
-static void
+static Eo *
 _efl_vg_container_eo_base_constructor(Eo *obj,
                                       Efl_VG_Container_Data *pd)
 {
    Efl_VG_Base_Data *nd;
 
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 
    nd = eo_data_scope_get(obj, EFL_VG_BASE_CLASS);
    nd->render_pre = _efl_vg_container_render_pre;
    nd->data = pd;
+
+   return obj;
 }
 
 static void

src/lib/evas/canvas/evas_vg_gradient_linear.c

@@ -88,17 +88,19 @@ _efl_vg_gradient_linear_render_pre(Eo *obj,
          ector_renderer_prepare());
 }
 
-static void
+static Eo *
 _efl_vg_gradient_linear_eo_base_constructor(Eo *obj,
                                             Efl_VG_Gradient_Linear_Data *pd)
 {
    Efl_VG_Base_Data *nd;
 
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 
    nd = eo_data_scope_get(obj, EFL_VG_BASE_CLASS);
    nd->render_pre = _efl_vg_gradient_linear_render_pre;
    nd->data = pd;
+
+   return obj;
 }
 
 static void

src/lib/evas/canvas/evas_vg_gradient_radial.c

@@ -105,16 +105,18 @@ _efl_vg_gradient_radial_render_pre(Eo *obj,
          ector_renderer_prepare());
 }
 
-static void
+static Eo *
 _efl_vg_gradient_radial_eo_base_constructor(Eo *obj, Efl_VG_Gradient_Radial_Data *pd)
 {
    Efl_VG_Base_Data *nd;
 
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 
    nd = eo_data_scope_get(obj, EFL_VG_BASE_CLASS);
    nd->render_pre = _efl_vg_gradient_radial_render_pre;
    nd->data = pd;
+
+   return obj;
 }
 
 static void

src/lib/evas/canvas/evas_vg_node.c

@@ -238,20 +238,22 @@ _efl_vg_base_parent_checked_get(Eo *obj,
    return EINA_FALSE;
 }
 
-static void
+static Eo *
 _efl_vg_base_eo_base_constructor(Eo *obj,
                                  Efl_VG_Base_Data *pd)
 {
    Efl_VG_Container_Data *cd = NULL;
    Eo *parent;
 
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 
    if (!_efl_vg_base_parent_checked_get(obj, &parent, &cd))
      eo_error_set(obj);
 
    eo_do(obj, eo_event_callback_add(EFL_GFX_CHANGED, _efl_vg_base_property_changed, pd));
    pd->changed = EINA_TRUE;
+
+   return obj;
 }
 
 static void

src/lib/evas/canvas/evas_vg_root_node.c

@@ -65,7 +65,7 @@ _efl_vg_root_node_eo_base_parent_set(Eo *obj,
      }
 }
 
-static void
+static Eo *
 _efl_vg_root_node_eo_base_constructor(Eo *obj,
                                       Efl_VG_Root_Node_Data *pd)
 {
@@ -74,7 +74,7 @@ _efl_vg_root_node_eo_base_constructor(Eo *obj,
    Eo *parent;
 
    // Nice little hack, jump over parent constructor in Efl_VG_Root
-   eo_do_super(obj, EFL_VG_BASE_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, EFL_VG_BASE_CLASS, obj, eo_constructor());
    eo_do(obj, parent = eo_parent_get());
    if (!eo_isa(parent, EVAS_VG_CLASS))
      eo_error_set(obj);
@@ -87,6 +87,8 @@ _efl_vg_root_node_eo_base_constructor(Eo *obj,
    nd->data = cd;
 
    eo_do(obj, eo_event_callback_add(EFL_GFX_CHANGED, _evas_vg_root_node_changed, pd));
+
+   return obj;
 }
 
 #include "efl_vg_root_node.eo.c"

src/lib/evas/canvas/evas_vg_shape.c

@@ -316,12 +316,12 @@ _efl_vg_shape_render_pre(Eo *obj EINA_UNUSED,
          ector_renderer_prepare());
 }
 
-static void
+static Eo *
 _efl_vg_shape_eo_base_constructor(Eo *obj, Efl_VG_Shape_Data *pd)
 {
    Efl_VG_Base_Data *nd;
 
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 
    pd->stroke.cap = EFL_GFX_CAP_BUTT;
    pd->stroke.join = EFL_GFX_JOIN_MITER;
@@ -331,6 +331,8 @@ _efl_vg_shape_eo_base_constructor(Eo *obj, Efl_VG_Shape_Data *pd)
    nd = eo_data_scope_get(obj, EFL_VG_BASE_CLASS);
    nd->render_pre = _efl_vg_shape_render_pre;
    nd->data = pd;
+
+   return obj;
 }
 
 static void

src/tests/eo/composite_objects/composite_objects_comp.c

@@ -21,11 +21,11 @@ _a_get(Eo *obj, void *class_data EINA_UNUSED)
    return a;
 }
 
-static void
+static Eo *
 _constructor(Eo *obj, void *class_data EINA_UNUSED)
 {
    Eina_Bool tmp;
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 
    Eo *simple = eo_add(SIMPLE_CLASS, obj);
    eo_do(obj, eo_composite_attach(simple));
@@ -35,6 +35,8 @@ _constructor(Eo *obj, void *class_data EINA_UNUSED)
    fail_if(!eo_do_ret(simple, tmp, eo_composite_part_is()));
 
    eo_do(obj, eo_key_data_set("simple-obj", simple, NULL));
+
+   return obj;
 }
 
 static Eo_Op_Description op_descs[] = {

src/tests/eo/constructors/constructors_mixin.c

@@ -18,12 +18,12 @@ _add_and_print_set(Eo *obj, void *class_data EINA_UNUSED, int x)
 
 extern int my_init_count;
 
-static void
+static Eo *
 _constructor(Eo *obj, void *class_data EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_constructor());
-
    my_init_count++;
+
+   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 }
 
 static void

src/tests/eo/constructors/constructors_simple.c

@@ -39,12 +39,12 @@ _GET_SET_FUNC(b)
 
 extern int my_init_count;
 
-static void
+static Eo *
 _constructor(Eo *obj, void *class_data EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_constructor());
-
    my_init_count++;
+
+   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 }
 
 static Eo*

src/tests/eo/constructors/constructors_simple2.c

@@ -8,12 +8,13 @@
 
 #define MY_CLASS SIMPLE2_CLASS
 
-static void
+static Eo *
 _constructor(Eo *obj, void *class_data EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 
    eo_error_set(obj);
+   return obj;
 }
 
 static Eo_Op_Description op_descs[] = {

src/tests/eo/constructors/constructors_simple3.c

@@ -8,10 +8,10 @@
 
 #define MY_CLASS SIMPLE3_CLASS
 
-static void
+static Eo *
 _constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
 {
-   (void) obj;
+   return obj;
 }
 
 static Eo_Op_Description op_descs[] = {

src/tests/eo/constructors/constructors_simple7.c

@@ -11,11 +11,11 @@
 
 #define MY_CLASS SIMPLE7_CLASS
 
-static void
+static Eo *
 _constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
 {
    /* FIXME: Actually test it. */
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 }
 
 static Eo_Op_Description op_descs [] = {

src/tests/eo/mixin/mixin_mixin.c

@@ -17,10 +17,10 @@ _ab_sum_get(Eo *obj, void *class_data EINA_UNUSED)
    return a + b;
 }
 
-static void
+static Eo *
 _constructor(Eo *obj, void *class_data EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 }
 
 static void

src/tests/eo/mixin/mixin_mixin2.c

@@ -32,10 +32,11 @@ _ab_sum_get(Eo *obj, void *class_data)
    return sum;
 }
 
-static void
+static Eo *
 _constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
+   return obj;
 }
 
 static void

src/tests/eo/mixin/mixin_mixin3.c

@@ -32,10 +32,10 @@ _ab_sum_get(Eo *obj, void *class_data EINA_UNUSED)
    return sum;
 }
 
-static void
+static Eo *
 _constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 }
 
 static void

src/tests/eo/signals/signals_simple.c

@@ -60,15 +60,17 @@ _cb_deled(void *data, Eo *obj, const Eo_Event_Description *desc, void *event_inf
    return EO_CALLBACK_CONTINUE;
 }
 
-static void
+static Eo *
 _constructor(Eo *obj, void *class_data EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 
    eo_do(obj, eo_event_callback_add(EO_EV_CALLBACK_ADD, _cb_added, NULL));
    eo_do(obj, eo_event_callback_add(EO_EV_CALLBACK_DEL, _cb_deled, NULL));
 
    eo_do(obj, eo_key_data_set("cb_count", (intptr_t) 0, NULL));
+
+   return obj;
 }
 
 EAPI EO_VOID_FUNC_BODYV(simple_a_set, EO_FUNC_CALL(a), int a);

src/tests/eo/suite/eo_test_general.c

@@ -296,12 +296,12 @@ static Eina_Bool _man_should_con = EINA_TRUE;
 static Eina_Bool _man_should_des = EINA_TRUE;
 static const Eo_Class *cur_klass = NULL;
 
-static void
+static Eo *
 _man_con(Eo *obj, void *data EINA_UNUSED, va_list *list EINA_UNUSED)
 {
    if (_man_should_con)
       eo_manual_free_set(obj, EINA_TRUE);
-   eo_do_super(obj, cur_klass, eo_constructor());
+   return eo_do_super_ret(obj, cur_klass, obj, eo_constructor());
 }
 
 static void

src/tests/eo/suite/eo_test_threaded_calls.c

@@ -49,12 +49,14 @@ _try_swap_stack(Eo *obj EINA_UNUSED, void *class_data)
      }
 }
 
-static void
+static Eo *
-_constructor(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED, int v)
+_constructor(Eo *obj, void *class_data EINA_UNUSED, int v)
 {
    Thread_Test_Public_Data *pd = class_data;
 
    pd->v = v;
+
+   return obj;
 }
 
 static Eo_Op_Description op_descs[] = {

src/tests/eolian_cxx/a.c

@@ -15,9 +15,9 @@ typedef struct _A_Data A_Data;
 
 #define MY_CLASS A_CLASS
 
-static void _a_eo_base_constructor(Eo *obj EINA_UNUSED, A_Data *pd EINA_UNUSED)
+static Eo *_a_eo_base_constructor(Eo *obj EINA_UNUSED, A_Data *pd EINA_UNUSED)
 {
-  eo_do_super(obj, MY_CLASS, eo_constructor());
+   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 }
 
 #include "a.eo.c"

src/tests/eolian_cxx/b.c

@@ -16,9 +16,9 @@ typedef struct _B_Data B_Data;
 
 #define MY_CLASS B_CLASS
 
-static void _b_eo_base_constructor(Eo *obj EINA_UNUSED, B_Data *pd EINA_UNUSED)
+static Eo *_b_eo_base_constructor(Eo *obj EINA_UNUSED, B_Data *pd EINA_UNUSED)
 {
-  eo_do_super(obj, MY_CLASS, eo_constructor());
+   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 }
 
 #include "b.eo.c"

src/tests/eolian_cxx/c.c

@@ -16,9 +16,9 @@ typedef struct _C_Data C_Data;
 
 #define MY_CLASS C_CLASS
 
-static void _c_eo_base_constructor(Eo *obj EINA_UNUSED, C_Data *pd EINA_UNUSED)
+static Eo *_c_eo_base_constructor(Eo *obj EINA_UNUSED, C_Data *pd EINA_UNUSED)
 {
-  eo_do_super(obj, MY_CLASS, eo_constructor());
+   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 }
 
 #include "c.eo.c"

src/tests/eolian_cxx/callback.c

@@ -28,13 +28,15 @@ static Eina_Bool _callback_callback_added(void* data EINA_UNUSED, Eo* obj EINA_U
   return EINA_TRUE;
 }
 
-static void _callback_eo_base_constructor(Eo *obj EINA_UNUSED, Callback_Data *pd EINA_UNUSED)
+static Eo *_callback_eo_base_constructor(Eo *obj, Callback_Data *pd EINA_UNUSED)
 {
   pd->callbacks = 0;
-  eo_do_super(obj, MY_CLASS, eo_constructor());
+  obj = eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 
   eo_event_callback_priority_add(EO_BASE_EVENT_CALLBACK_ADD, EO_CALLBACK_PRIORITY_DEFAULT
                                  , &_callback_callback_added, pd);
+
+  return obj;
 }
 
 static void _callback_onecallback(Eo *obj EINA_UNUSED, Callback_Data *pd EINA_UNUSED, Ecore_Cb cb, void *data)

src/tests/eolian_cxx/d.c

@@ -18,9 +18,9 @@ typedef struct _D_Data D_Data;
 
 #define MY_CLASS D_CLASS
 
-static void _d_eo_base_constructor(Eo *obj EINA_UNUSED, D_Data *pd EINA_UNUSED)
+static Eo *_d_eo_base_constructor(Eo *obj EINA_UNUSED, D_Data *pd EINA_UNUSED)
 {
-  eo_do_super(obj, MY_CLASS, eo_constructor());
+   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 }
 
 #include "d.eo.c"

src/tests/eolian_cxx/simple.c

@@ -12,9 +12,9 @@
 
 #define MY_CLASS SIMPLE_CLASS
 
-static void _simple_eo_base_constructor(Eo *obj, void *pd EINA_UNUSED)
+static Eo *_simple_eo_base_constructor(Eo *obj, void *pd EINA_UNUSED)
 {
-   eo_do_super(obj, MY_CLASS, eo_constructor());
+   return eo_do_super_ret(obj, MY_CLASS, obj, eo_constructor());
 }
 
 static Eina_Bool _simple_simple_get(Eo *obj EINA_UNUSED, void *pd EINA_UNUSED)