diff --git a/src/lib/eolian/Eolian.h b/src/lib/eolian/Eolian.h
index f8bea89811..05aa1ea22d 100644
--- a/src/lib/eolian/Eolian.h
+++ b/src/lib/eolian/Eolian.h
@@ -537,6 +537,7 @@ EAPI void eolian_state_free(Eolian_State *state);
  * @see eolian_object_file_get
  * @see eolian_object_line_get
  * @see eolian_object_column_get
+ * @see eolian_object_name_get
  *
  * @ingroup Eolian
  */
@@ -551,6 +552,7 @@ EAPI Eolian_Object_Type eolian_object_type_get(const Eolian_Object *obj);
  * @see eolian_object_type_get
  * @see eolian_object_line_get
  * @see eolian_object_column_get
+ * @see eolian_object_name_get
  *
  * @ingroup Eolian
  */
@@ -564,6 +566,7 @@ EAPI const char *eolian_object_file_get(const Eolian_Object *obj);
  * @see eolian_object_type_get
  * @see eolian_object_file_get
  * @see eolian_object_column_get
+ * @see eolian_object_name_get
  *
  * @ingroup Eolian
  */
@@ -580,11 +583,28 @@ EAPI int eolian_object_line_get(const Eolian_Object *obj);
  * @see eolian_object_type_get
  * @see eolian_object_file_get
  * @see eolian_object_line_get
+ * @see eolian_object_name_get
  *
  * @ingroup Eolian
  */
 EAPI int eolian_object_column_get(const Eolian_Object *obj);
 
+/*
+ * @brief Get the name of an object.
+ *
+ * This name is the full name of the object, if named at all.
+ * For toplevel file declarations, this will be the fully namespaced
+ * name, for things like params this will be just the name itself.
+ *
+ * @see eolian_object_type_get
+ * @see eolian_object_file_get
+ * @see eolian_object_line_get
+ * @see eolian_object_column_get
+ *
+ * @ingroup Eolian
+ */
+EAPI const char *eolian_object_name_get(const Eolian_Object *obj);
+
 /*
  * @brief Scan the given directory for .eo and .eot files.
  *
diff --git a/src/lib/eolian/database_class.c b/src/lib/eolian/database_class.c
index 92556e9600..1fb50922da 100644
--- a/src/lib/eolian/database_class.c
+++ b/src/lib/eolian/database_class.c
@@ -17,7 +17,8 @@ database_class_del(Eolian_Class *cl)
 
    if (!cl || eolian_object_unref(&cl->base)) return;
 
-   if (cl->base.file) eina_stringshare_del(cl->base.file);
+   eina_stringshare_del(cl->base.file);
+   eina_stringshare_del(cl->base.name);
 
    EINA_LIST_FREE(cl->implements, impl)
      database_implement_del(impl);
@@ -31,7 +32,6 @@ database_class_del(Eolian_Class *cl)
    EINA_LIST_FREE(cl->parts, pt) database_part_del(pt);
 
    if (cl->name) eina_stringshare_del(cl->name);
-   if (cl->full_name) eina_stringshare_del(cl->full_name);
    if (cl->legacy_prefix) eina_stringshare_del(cl->legacy_prefix);
    if (cl->eo_prefix) eina_stringshare_del(cl->eo_prefix);
    if (cl->ev_prefix) eina_stringshare_del(cl->ev_prefix);
diff --git a/src/lib/eolian/database_class_api.c b/src/lib/eolian/database_class_api.c
index 2703d0e200..42125ade63 100644
--- a/src/lib/eolian/database_class_api.c
+++ b/src/lib/eolian/database_class_api.c
@@ -15,7 +15,7 @@ eolian_class_file_get(const Eolian_Class *cl)
 EAPI Eina_Stringshare *
 eolian_class_full_name_get(const Eolian_Class *cl)
 {
-   return cl ? cl->full_name : NULL;
+   return cl ? cl->base.name : NULL;
 }
 
 EAPI Eina_Stringshare *
@@ -104,7 +104,7 @@ eolian_class_function_get_by_name(const Eolian_Class *cl, const char *func_name,
    if (f_type == EOLIAN_UNRESOLVED || f_type == EOLIAN_METHOD)
       EINA_LIST_FOREACH(cl->methods, itr, fid)
         {
-           if (!strcmp(fid->name, func_name))
+           if (!strcmp(fid->base.name, func_name))
               return fid;
         }
 
@@ -115,7 +115,7 @@ eolian_class_function_get_by_name(const Eolian_Class *cl, const char *func_name,
           {
              if (!database_function_is_type(fid, f_type))
                continue;
-             if (!strcmp(fid->name, func_name))
+             if (!strcmp(fid->base.name, func_name))
                 return fid;
           }
      }
@@ -173,7 +173,7 @@ eolian_class_c_get_function_name_get(const Eolian_Class *cl)
    Eina_Stringshare *ret;
    Eina_Strbuf *buf = eina_strbuf_new();
    char *bufp;
-   eina_strbuf_append(buf, cl->full_name);
+   eina_strbuf_append(buf, cl->base.name);
    switch (cl->type)
      {
       case EOLIAN_CLASS_INTERFACE:
@@ -202,7 +202,7 @@ eolian_class_c_name_get(const Eolian_Class *cl)
    Eina_Stringshare *ret;
    Eina_Strbuf *buf = eina_strbuf_new();
    char *bufp;
-   eina_strbuf_append(buf, cl->full_name);
+   eina_strbuf_append(buf, cl->base.name);
    switch (cl->type)
      {
       case EOLIAN_CLASS_INTERFACE:
@@ -230,7 +230,7 @@ eolian_class_c_data_type_get(const Eolian_Class *cl)
    char buf[512];
    EINA_SAFETY_ON_NULL_RETURN_VAL(cl, NULL);
    if (!cl->data_type)
-     snprintf(buf, sizeof(buf), "%s_Data", cl->full_name);
+     snprintf(buf, sizeof(buf), "%s_Data", cl->base.name);
    else if (!strcmp(cl->data_type, "null"))
      return eina_stringshare_add("void");
    else
diff --git a/src/lib/eolian/database_constructor.c b/src/lib/eolian/database_constructor.c
index 2c1370209f..1d0f4a4f25 100644
--- a/src/lib/eolian/database_constructor.c
+++ b/src/lib/eolian/database_constructor.c
@@ -9,7 +9,7 @@ void
 database_constructor_del(Eolian_Constructor *ctor)
 {
    if (!ctor) return;
-   if (ctor->base.file) eina_stringshare_del(ctor->base.file);
-   if (ctor->full_name) eina_stringshare_del(ctor->full_name);
+   eina_stringshare_del(ctor->base.file);
+   eina_stringshare_del(ctor->base.name);
    free(ctor);
 }
diff --git a/src/lib/eolian/database_constructor_api.c b/src/lib/eolian/database_constructor_api.c
index 90b1d47e97..da2cbc4e86 100644
--- a/src/lib/eolian/database_constructor_api.c
+++ b/src/lib/eolian/database_constructor_api.c
@@ -9,7 +9,7 @@ EAPI Eina_Stringshare *
 eolian_constructor_full_name_get(const Eolian_Constructor *ctor)
 {
    EINA_SAFETY_ON_NULL_RETURN_VAL(ctor, NULL);
-   return ctor->full_name;
+   return ctor->base.name;
 }
 
 EAPI const Eolian_Class *
@@ -27,7 +27,7 @@ eolian_constructor_function_get(const Eolian_Constructor *ctor)
    if (!klass)
      return NULL;
    return eolian_class_function_get_by_name(klass,
-       ctor->full_name + strlen(klass->full_name) + 1, EOLIAN_UNRESOLVED);
+       ctor->base.name + strlen(klass->base.name) + 1, EOLIAN_UNRESOLVED);
 }
 
 EAPI Eina_Bool
diff --git a/src/lib/eolian/database_event.c b/src/lib/eolian/database_event.c
index 6dcd953990..6513787ea8 100644
--- a/src/lib/eolian/database_event.c
+++ b/src/lib/eolian/database_event.c
@@ -9,7 +9,8 @@ void
 database_event_del(Eolian_Event *event)
 {
    if (!event) return;
-   if (event->name) eina_stringshare_del(event->name);
+   eina_stringshare_del(event->base.file);
+   eina_stringshare_del(event->base.name);
    database_type_del(event->type);
    database_doc_del(event->doc);
    free(event);
diff --git a/src/lib/eolian/database_event_api.c b/src/lib/eolian/database_event_api.c
index 0bd4acce86..728c87e1fa 100644
--- a/src/lib/eolian/database_event_api.c
+++ b/src/lib/eolian/database_event_api.c
@@ -9,7 +9,7 @@ EAPI Eina_Stringshare *
 eolian_event_name_get(const Eolian_Event *event)
 {
    EINA_SAFETY_ON_NULL_RETURN_VAL(event, NULL);
-   return event->name;
+   return event->base.name;
 }
 
 EAPI const Eolian_Type *
@@ -61,8 +61,8 @@ eolian_event_c_name_get(const Eolian_Event *event)
     char *tmp = buf;
     const char *pfx = event->klass->ev_prefix;
     if (!pfx) pfx = event->klass->eo_prefix;
-    if (!pfx) pfx = event->klass->full_name;
-    snprintf(buf, sizeof(buf), "%s_EVENT_%s", pfx, event->name);
+    if (!pfx) pfx = event->klass->base.name;
+    snprintf(buf, sizeof(buf), "%s_EVENT_%s", pfx, event->base.name);
     eina_str_toupper(&tmp);
     while ((tmp = strpbrk(tmp, ".,"))) *tmp = '_';
     return eina_stringshare_add(buf);
@@ -78,7 +78,7 @@ eolian_class_event_get_by_name(const Eolian_Class *klass, const char *event_name
 
    EINA_LIST_FOREACH(klass->events, itr, event)
         {
-           if (event->name == shr_ev)
+           if (event->base.name == shr_ev)
               goto end;
         }
 
diff --git a/src/lib/eolian/database_function.c b/src/lib/eolian/database_function.c
index 8cf7171f1e..15187e93d7 100644
--- a/src/lib/eolian/database_function.c
+++ b/src/lib/eolian/database_function.c
@@ -12,8 +12,8 @@ database_function_del(Eolian_Function *fid)
    Eina_Stringshare *cls_name;
    if (!fid) return;
 
-   if (fid->base.file) eina_stringshare_del(fid->base.file);
-   eina_stringshare_del(fid->name);
+   eina_stringshare_del(fid->base.file);
+   eina_stringshare_del(fid->base.name);
    EINA_LIST_FREE(fid->prop_values, param) database_parameter_del(param);
    EINA_LIST_FREE(fid->prop_values_get, param) database_parameter_del(param);
    EINA_LIST_FREE(fid->prop_values_set, param) database_parameter_del(param);
@@ -55,7 +55,7 @@ database_function_constructor_add(Eolian_Function *func, const Eolian_Class *cls
 {
    func->ctor_of = _list_sorted_insert_no_dup
      (func->ctor_of, EINA_COMPARE_CB(strcmp),
-      eina_stringshare_ref(cls->full_name));
+      eina_stringshare_ref(cls->base.name));
 }
 
 Eina_Bool
diff --git a/src/lib/eolian/database_function_api.c b/src/lib/eolian/database_function_api.c
index fffced476b..a5c1d7befd 100644
--- a/src/lib/eolian/database_function_api.c
+++ b/src/lib/eolian/database_function_api.c
@@ -41,7 +41,7 @@ EAPI Eina_Stringshare *
 eolian_function_name_get(const Eolian_Function *fid)
 {
    EINA_SAFETY_ON_NULL_RETURN_VAL(fid, NULL);
-   return fid->name;
+   return fid->base.name;
 }
 
 static const char *
@@ -52,7 +52,7 @@ _get_eo_prefix(const Eolian_Function *foo_id, char *buf, Eina_Bool use_legacy)
       return foo_id->klass->legacy_prefix;
     else if (foo_id->klass->eo_prefix)
       return foo_id->klass->eo_prefix;
-    strcpy(buf, foo_id->klass->full_name);
+    strcpy(buf, foo_id->klass->base.name);
     eina_str_tolower(&buf);
     while ((tmp = strchr(tmp, '.'))) *tmp = '_';
     return buf;
@@ -229,7 +229,7 @@ EAPI Eina_Bool
 eolian_function_is_constructor(const Eolian_Function *fid, const Eolian_Class *klass)
 {
    EINA_SAFETY_ON_NULL_RETURN_VAL(fid, EINA_FALSE);
-   Eina_Stringshare *s = eina_stringshare_ref(klass->full_name);
+   Eina_Stringshare *s = eina_stringshare_ref(klass->base.name);
    Eina_Bool r = !!eina_list_search_sorted_list
      (fid->ctor_of, EINA_COMPARE_CB(strcmp), s);
    eina_stringshare_del(s);
diff --git a/src/lib/eolian/database_function_parameter.c b/src/lib/eolian/database_function_parameter.c
index f10a52a47c..dbab917f19 100644
--- a/src/lib/eolian/database_function_parameter.c
+++ b/src/lib/eolian/database_function_parameter.c
@@ -8,8 +8,8 @@
 void
 database_parameter_del(Eolian_Function_Parameter *pdesc)
 {
-   if (pdesc->base.file) eina_stringshare_del(pdesc->base.file);
-   eina_stringshare_del(pdesc->name);
+   eina_stringshare_del(pdesc->base.file);
+   eina_stringshare_del(pdesc->base.name);
 
    database_type_del(pdesc->type);
    database_expr_del(pdesc->value);
diff --git a/src/lib/eolian/database_function_parameter_api.c b/src/lib/eolian/database_function_parameter_api.c
index 34100efbbe..36fa9818eb 100644
--- a/src/lib/eolian/database_function_parameter_api.c
+++ b/src/lib/eolian/database_function_parameter_api.c
@@ -30,7 +30,7 @@ EAPI Eina_Stringshare *
 eolian_parameter_name_get(const Eolian_Function_Parameter *param)
 {
    EINA_SAFETY_ON_NULL_RETURN_VAL(param, NULL);
-   return param->name;
+   return param->base.name;
 }
 
 EAPI const Eolian_Documentation *
diff --git a/src/lib/eolian/database_implement.c b/src/lib/eolian/database_implement.c
index df055aca47..b97a88f7ca 100644
--- a/src/lib/eolian/database_implement.c
+++ b/src/lib/eolian/database_implement.c
@@ -9,8 +9,8 @@ void
 database_implement_del(Eolian_Implement *impl)
 {
    if (!impl) return;
-   if (impl->base.file) eina_stringshare_del(impl->base.file);
-   if (impl->full_name) eina_stringshare_del(impl->full_name);
+   eina_stringshare_del(impl->base.file);
+   eina_stringshare_del(impl->base.name);
    database_doc_del(impl->common_doc);
    database_doc_del(impl->get_doc);
    database_doc_del(impl->set_doc);
diff --git a/src/lib/eolian/database_implement_api.c b/src/lib/eolian/database_implement_api.c
index 2899b2093f..21d5456aec 100644
--- a/src/lib/eolian/database_implement_api.c
+++ b/src/lib/eolian/database_implement_api.c
@@ -9,7 +9,7 @@ EAPI Eina_Stringshare *
 eolian_implement_full_name_get(const Eolian_Implement *impl)
 {
    EINA_SAFETY_ON_NULL_RETURN_VAL(impl, NULL);
-   return impl->full_name;
+   return impl->base.name;
 }
 
 EAPI const Eolian_Class *
diff --git a/src/lib/eolian/database_part.c b/src/lib/eolian/database_part.c
index 853eeadfca..57603a2abb 100644
--- a/src/lib/eolian/database_part.c
+++ b/src/lib/eolian/database_part.c
@@ -9,7 +9,8 @@ void
 database_part_del(Eolian_Part *part)
 {
    if (!part) return;
-   eina_stringshare_del(part->name);
+   eina_stringshare_del(part->base.file);
+   eina_stringshare_del(part->base.name);
    if (!part->base.validated)
      eina_stringshare_del(part->klass_name);
    database_doc_del(part->doc);
diff --git a/src/lib/eolian/database_part_api.c b/src/lib/eolian/database_part_api.c
index a67b0d4391..71166f18ed 100644
--- a/src/lib/eolian/database_part_api.c
+++ b/src/lib/eolian/database_part_api.c
@@ -9,7 +9,7 @@ EAPI Eina_Stringshare *
 eolian_part_name_get(const Eolian_Part *part)
 {
    EINA_SAFETY_ON_NULL_RETURN_VAL(part, NULL);
-   return part->name;
+   return part->base.name;
 }
 
 EAPI const Eolian_Class *
diff --git a/src/lib/eolian/database_type.c b/src/lib/eolian/database_type.c
index 7ffeda303f..b89cb0d054 100644
--- a/src/lib/eolian/database_type.c
+++ b/src/lib/eolian/database_type.c
@@ -10,11 +10,11 @@ database_type_del(Eolian_Type *tp)
 {
    if (!tp || eolian_object_unref(&tp->base)) return;
    const char *sp;
-   if (tp->base.file) eina_stringshare_del(tp->base.file);
+   eina_stringshare_del(tp->base.file);
+   eina_stringshare_del(tp->base.name);
    database_type_del(tp->base_type);
    database_type_del(tp->next_type);
    if (tp->name) eina_stringshare_del(tp->name);
-   if (tp->full_name) eina_stringshare_del(tp->full_name);
    if (tp->namespaces) EINA_LIST_FREE(tp->namespaces, sp)
      eina_stringshare_del(sp);
    if (tp->freefunc) eina_stringshare_del(tp->freefunc);
@@ -26,10 +26,10 @@ database_typedecl_del(Eolian_Typedecl *tp)
 {
    if (!tp || eolian_object_unref(&tp->base)) return;
    const char *sp;
-   if (tp->base.file) eina_stringshare_del(tp->base.file);
+   eina_stringshare_del(tp->base.file);
+   eina_stringshare_del(tp->base.name);
    database_type_del(tp->base_type);
    if (tp->name) eina_stringshare_del(tp->name);
-   if (tp->full_name) eina_stringshare_del(tp->full_name);
    if (tp->fields) eina_hash_free(tp->fields);
    if (tp->field_list) eina_list_free(tp->field_list);
    if (tp->namespaces) EINA_LIST_FREE(tp->namespaces, sp)
@@ -43,29 +43,29 @@ database_typedecl_del(Eolian_Typedecl *tp)
 void
 database_type_add(Eolian_Unit *unit, Eolian_Typedecl *tp)
 {
-   EOLIAN_OBJECT_ADD(unit, tp->full_name, tp, aliases);
+   EOLIAN_OBJECT_ADD(unit, tp->base.name, tp, aliases);
    eina_hash_set(unit->state->aliases_f, tp->base.file, eina_list_append
                 ((Eina_List*)eina_hash_find(unit->state->aliases_f, tp->base.file),
                 tp));
-   database_decl_add(unit, tp->full_name, EOLIAN_DECL_ALIAS, tp->base.file, tp);
+   database_decl_add(unit, tp->base.name, EOLIAN_DECL_ALIAS, tp->base.file, tp);
 }
 
 void
 database_struct_add(Eolian_Unit *unit, Eolian_Typedecl *tp)
 {
-   EOLIAN_OBJECT_ADD(unit, tp->full_name, tp, structs);
+   EOLIAN_OBJECT_ADD(unit, tp->base.name, tp, structs);
    eina_hash_set(unit->state->structs_f, tp->base.file, eina_list_append
                 ((Eina_List*)eina_hash_find(unit->state->structs_f, tp->base.file), tp));
-   database_decl_add(unit, tp->full_name, EOLIAN_DECL_STRUCT, tp->base.file, tp);
+   database_decl_add(unit, tp->base.name, EOLIAN_DECL_STRUCT, tp->base.file, tp);
 }
 
 void
 database_enum_add(Eolian_Unit *unit, Eolian_Typedecl *tp)
 {
-   EOLIAN_OBJECT_ADD(unit, tp->full_name, tp, enums);
+   EOLIAN_OBJECT_ADD(unit, tp->base.name, tp, enums);
    eina_hash_set(unit->state->enums_f, tp->base.file, eina_list_append
                 ((Eina_List*)eina_hash_find(unit->state->enums_f, tp->base.file), tp));
-   database_decl_add(unit, tp->full_name, EOLIAN_DECL_ENUM, tp->base.file, tp);
+   database_decl_add(unit, tp->base.name, EOLIAN_DECL_ENUM, tp->base.file, tp);
 }
 
 Eina_Bool
@@ -169,7 +169,7 @@ _stype_to_str(const Eolian_Typedecl *tp, Eina_Strbuf *buf)
    eina_strbuf_append(buf, " { ");
    EINA_LIST_FOREACH(tp->field_list, l, sf)
      {
-        database_type_to_str(sf->type, buf, sf->name,
+        database_type_to_str(sf->type, buf, sf->base.name,
                              EOLIAN_C_TYPE_DEFAULT);
         eina_strbuf_append(buf, "; ");
      }
@@ -192,7 +192,7 @@ _etype_to_str(const Eolian_Typedecl *tp, Eina_Strbuf *buf)
    eina_strbuf_append(buf, " { ");
    EINA_LIST_FOREACH(tp->field_list, l, ef)
      {
-        eina_strbuf_append(buf, ef->name);
+        eina_strbuf_append(buf, ef->base.name);
         if (ef->value)
           {
              Eolian_Value val = eolian_expression_eval(ef->value,
@@ -275,10 +275,10 @@ Eolian_Typedecl *database_type_decl_find(const Eolian_Unit *unit, const Eolian_T
    /* try looking up if it belongs to a struct, enum or an alias... otherwise
     * return NULL, but first check for builtins
     */
-   int  kw = eo_lexer_keyword_str_to_id(tp->full_name);
+   int  kw = eo_lexer_keyword_str_to_id(tp->base.name);
    if (!kw || kw < KW_byte || kw >= KW_true)
      {
-        Eolian_Declaration *decl = eina_hash_find(unit->decls, tp->full_name);
+        Eolian_Declaration *decl = eina_hash_find(unit->decls, tp->base.name);
         if (decl && decl->type != EOLIAN_DECL_CLASS
                  && decl->type != EOLIAN_DECL_VAR)
           return decl->data;
diff --git a/src/lib/eolian/database_type_api.c b/src/lib/eolian/database_type_api.c
index 544ce4368e..c5f35083fb 100644
--- a/src/lib/eolian/database_type_api.c
+++ b/src/lib/eolian/database_type_api.c
@@ -53,7 +53,7 @@ EAPI Eina_Stringshare *
 eolian_typedecl_struct_field_name_get(const Eolian_Struct_Type_Field *fl)
 {
    EINA_SAFETY_ON_NULL_RETURN_VAL(fl, NULL);
-   return fl->name;
+   return fl->base.name;
 }
 
 EAPI const Eolian_Documentation *
@@ -96,7 +96,7 @@ EAPI Eina_Stringshare *
 eolian_typedecl_enum_field_name_get(const Eolian_Enum_Type_Field *fl)
 {
    EINA_SAFETY_ON_NULL_RETURN_VAL(fl, NULL);
-   return fl->name;
+   return fl->base.name;
 }
 
 EAPI Eina_Stringshare *
@@ -110,9 +110,9 @@ eolian_typedecl_enum_field_c_name_get(const Eolian_Enum_Type_Field *fl)
    if (fl->base_enum->legacy)
      eina_strbuf_append(buf, fl->base_enum->legacy);
    else
-     eina_strbuf_append(buf, fl->base_enum->full_name);
+     eina_strbuf_append(buf, fl->base_enum->base.name);
    eina_strbuf_append_char(buf, '_');
-   eina_strbuf_append(buf, fl->name);
+   eina_strbuf_append(buf, fl->base.name);
    bufp = eina_strbuf_string_steal(buf);
    eina_strbuf_free(buf);
    eina_str_toupper(&bufp);
@@ -297,14 +297,14 @@ EAPI Eina_Stringshare *
 eolian_type_full_name_get(const Eolian_Type *tp)
 {
    EINA_SAFETY_ON_NULL_RETURN_VAL(tp, NULL);
-   return tp->full_name;
+   return tp->base.name;
 }
 
 EAPI Eina_Stringshare *
 eolian_typedecl_full_name_get(const Eolian_Typedecl *tp)
 {
    EINA_SAFETY_ON_NULL_RETURN_VAL(tp, NULL);
-   return tp->full_name;
+   return tp->base.name;
 }
 
 EAPI Eina_Iterator *
diff --git a/src/lib/eolian/database_validate.c b/src/lib/eolian/database_validate.c
index 02cfb0f47e..90a0b54e4d 100644
--- a/src/lib/eolian/database_validate.c
+++ b/src/lib/eolian/database_validate.c
@@ -186,7 +186,7 @@ _validate_type(Validate_State *vals, const Eolian_Unit *src, Eolian_Type *tp)
    char buf[256];
    if (tp->owned && !database_type_is_ownable(src, tp))
      {
-        snprintf(buf, sizeof(buf), "type '%s' is not ownable", tp->full_name);
+        snprintf(buf, sizeof(buf), "type '%s' is not ownable", tp->base.name);
         return _obj_error(&tp->base, buf);
      }
 
@@ -210,7 +210,7 @@ _validate_type(Validate_State *vals, const Eolian_Unit *src, Eolian_Type *tp)
         {
            if (tp->base_type)
              {
-                int kwid = eo_lexer_keyword_str_to_id(tp->full_name);
+                int kwid = eo_lexer_keyword_str_to_id(tp->base.name);
                 if (!tp->freefunc)
                   {
                      tp->freefunc = eina_stringshare_add(eo_complex_frees[
@@ -228,7 +228,7 @@ _validate_type(Validate_State *vals, const Eolian_Unit *src, Eolian_Type *tp)
                             {
                                snprintf(buf, sizeof(buf),
                                         "%s cannot contain value types (%s)",
-                                        tp->full_name, itp->full_name);
+                                        tp->base.name, itp->base.name);
                                return _obj_error(&itp->base, buf);
                             }
                        }
@@ -237,7 +237,7 @@ _validate_type(Validate_State *vals, const Eolian_Unit *src, Eolian_Type *tp)
                 return _validate(&tp->base);
              }
            /* builtins */
-           int id = eo_lexer_keyword_str_to_id(tp->full_name);
+           int id = eo_lexer_keyword_str_to_id(tp->base.name);
            if (id)
              {
                 if (!eo_lexer_is_type_keyword(id))
@@ -266,7 +266,7 @@ _validate_type(Validate_State *vals, const Eolian_Unit *src, Eolian_Type *tp)
            tp->tdecl = database_type_decl_find(src, tp);
            if (!tp->tdecl)
              {
-                snprintf(buf, sizeof(buf), "undefined type %s", tp->full_name);
+                snprintf(buf, sizeof(buf), "undefined type %s", tp->base.name);
                 return _obj_error(&tp->base, buf);
              }
            if (!_validate_typedecl(vals, src, tp->tdecl))
@@ -277,11 +277,11 @@ _validate_type(Validate_State *vals, const Eolian_Unit *src, Eolian_Type *tp)
         }
       case EOLIAN_TYPE_CLASS:
         {
-           tp->klass = (Eolian_Class *)eolian_unit_class_by_name_get(src, tp->full_name);
+           tp->klass = (Eolian_Class *)eolian_unit_class_by_name_get(src, tp->base.name);
            if (!tp->klass)
              {
                 snprintf(buf, sizeof(buf), "undefined class %s "
-                         "(likely wrong namespacing)", tp->full_name);
+                         "(likely wrong namespacing)", tp->base.name);
                 return _obj_error(&tp->base, buf);
              }
            if (!tp->freefunc)
@@ -333,12 +333,12 @@ _validate_function(Validate_State *vals, const Eolian_Unit *src,
    Eolian_Function_Parameter *param;
    char buf[512];
 
-   const Eolian_Function *ofunc = nhash ? eina_hash_find(nhash, func->name) : NULL;
+   const Eolian_Function *ofunc = nhash ? eina_hash_find(nhash, func->base.name) : NULL;
    if (EINA_UNLIKELY(ofunc && (ofunc != func)))
      {
         snprintf(buf, sizeof(buf),
                  "%sfunction '%s' redefined (originally at %s:%d:%d)",
-                 func->is_beta ? "beta " : "", func->name, ofunc->base.file,
+                 func->is_beta ? "beta " : "", func->base.name, ofunc->base.file,
                  ofunc->base.line, ofunc->base.column);
         _obj_error(&func->base, buf);
         vals->warned = EINA_TRUE;
@@ -351,7 +351,7 @@ _validate_function(Validate_State *vals, const Eolian_Unit *src,
      {
         /* it might be validated, but need to add it anyway */
         if (!ofunc && nhash)
-          eina_hash_add(nhash, func->name, func);
+          eina_hash_add(nhash, func->base.name, func);
         return EINA_TRUE;
      }
 
@@ -390,7 +390,7 @@ _validate_function(Validate_State *vals, const Eolian_Unit *src,
 
    /* just for now, when dups become errors there will be no need to check */
    if (!ofunc && nhash)
-     eina_hash_add(nhash, func->name, func);
+     eina_hash_add(nhash, func->base.name, func);
 
    return _validate(&func->base);
 }
@@ -398,13 +398,13 @@ _validate_function(Validate_State *vals, const Eolian_Unit *src,
 static Eina_Bool
 _validate_part(const Eolian_Unit *src, Eolian_Part *part, Eina_Hash *nhash)
 {
-   const Eolian_Function *ofunc = eina_hash_find(nhash, part->name);
+   const Eolian_Function *ofunc = eina_hash_find(nhash, part->base.name);
    if (ofunc)
      {
         char buf[512];
         snprintf(buf, sizeof(buf),
                  "part '%s' conflicts with a function (defined at %s:%d:%d)",
-                 part->name, ofunc->base.file,
+                 part->base.name, ofunc->base.file,
                  ofunc->base.line, ofunc->base.column);
         _obj_error(&part->base, buf);
      }
@@ -450,7 +450,7 @@ _validate_event(Validate_State *vals, const Eolian_Unit *src, Eolian_Event *even
 const Eolian_Class *
 _get_impl_class(const Eolian_Class *cl, const char *cln)
 {
-   if (!cl || !strcmp(cl->full_name, cln))
+   if (!cl || !strcmp(cl->base.name, cln))
      return cl;
    Eina_List *l;
    Eolian_Class *icl;
@@ -481,9 +481,9 @@ _db_fill_implement(Eolian_Class *cl, Eolian_Implement *impl)
    else if (impl->is_prop_set)
      ftype = EOLIAN_PROP_SET;
 
-   size_t imlen = strlen(impl->full_name);
+   size_t imlen = strlen(impl->base.name);
    char *clbuf = alloca(imlen + 1);
-   memcpy(clbuf, impl->full_name, imlen + 1);
+   memcpy(clbuf, impl->base.name, imlen + 1);
 
    char *ldot = strrchr(clbuf, '.');
    if (!ldot)
@@ -497,7 +497,7 @@ _db_fill_implement(Eolian_Class *cl, Eolian_Implement *impl)
    if (!tcl)
      {
         _eo_parser_log(&impl->base, "class '%s' not found within the inheritance tree of '%s'",
-                       clname, cl->full_name);
+                       clname, cl->base.name);
         return EINA_FALSE;
      }
 
@@ -555,7 +555,7 @@ _db_fill_implement(Eolian_Class *cl, Eolian_Implement *impl)
         /* only allow explicit implements from other classes, besides auto and
          * empty... also prevents pure virtuals from being implemented
          */
-        _eo_parser_log(&impl->base, "invalid implement '%s'", impl->full_name);
+        _eo_parser_log(&impl->base, "invalid implement '%s'", impl->base.name);
         return EINA_FALSE;
      }
 
@@ -577,9 +577,9 @@ _db_fill_implements(Eolian_Class *cl)
    EINA_LIST_FOREACH(cl->implements, l, impl)
      {
         Eina_Bool prop = (impl->is_prop_get || impl->is_prop_set);
-        if (eina_hash_find(prop ? pth : th, impl->full_name))
+        if (eina_hash_find(prop ? pth : th, impl->base.name))
           {
-             _eo_parser_log(&impl->base, "duplicate implement '%s'", impl->full_name);
+             _eo_parser_log(&impl->base, "duplicate implement '%s'", impl->base.name);
              ret = EINA_FALSE;
              goto end;
           }
@@ -598,7 +598,7 @@ _db_fill_implements(Eolian_Class *cl)
              ret = EINA_FALSE;
              goto end;
           }
-        eina_hash_add(prop ? pth : th, impl->full_name, impl->full_name);
+        eina_hash_add(prop ? pth : th, impl->base.name, impl->base.name);
      }
 
 end:
@@ -618,26 +618,26 @@ _db_fill_ctors(Eolian_Class *cl)
    Eina_Hash *th = eina_hash_string_small_new(NULL);
    EINA_LIST_FOREACH(cl->constructors, l, ctor)
      {
-        if (eina_hash_find(th, ctor->full_name))
+        if (eina_hash_find(th, ctor->base.name))
           {
-             _eo_parser_log(&ctor->base, "duplicate ctor '%s'", ctor->full_name);
+             _eo_parser_log(&ctor->base, "duplicate ctor '%s'", ctor->base.name);
              ret = EINA_FALSE;
              goto end;
           }
-        const char *ldot = strrchr(ctor->full_name, '.');
+        const char *ldot = strrchr(ctor->base.name, '.');
         if (!ldot)
           {
              ret = EINA_FALSE;
              goto end;
           }
-        char *cnbuf = alloca(ldot - ctor->full_name + 1);
-        memcpy(cnbuf, ctor->full_name, ldot - ctor->full_name);
-        cnbuf[ldot - ctor->full_name] = '\0';
+        char *cnbuf = alloca(ldot - ctor->base.name + 1);
+        memcpy(cnbuf, ctor->base.name, ldot - ctor->base.name);
+        cnbuf[ldot - ctor->base.name] = '\0';
         const Eolian_Class *tcl = _get_impl_class(cl, cnbuf);
         if (!tcl)
           {
              _eo_parser_log(&ctor->base, "class '%s' not found within the inheritance tree of '%s'",
-                            cnbuf, cl->full_name);
+                            cnbuf, cl->base.name);
              ret = EINA_FALSE;
              goto end;
           }
@@ -645,12 +645,12 @@ _db_fill_ctors(Eolian_Class *cl)
         const Eolian_Function *cfunc = eolian_constructor_function_get(ctor);
         if (!cfunc)
           {
-             _eo_parser_log(&ctor->base, "unable to find function '%s'", ctor->full_name);
+             _eo_parser_log(&ctor->base, "unable to find function '%s'", ctor->base.name);
              ret = EINA_FALSE;
              goto end;
           }
         database_function_constructor_add((Eolian_Function *)cfunc, tcl);
-        eina_hash_add(th, ctor->full_name, ctor->full_name);
+        eina_hash_add(th, ctor->base.name, ctor->base.name);
      }
 
 end:
@@ -661,7 +661,7 @@ end:
 static Eina_Bool
 _db_fill_inherits(const Eolian_Unit *src, Eolian_Class *cl, Eina_Hash *fhash)
 {
-   if (eina_hash_find(fhash, cl->full_name))
+   if (eina_hash_find(fhash, cl->base.name))
      return EINA_TRUE;
 
    Eina_List *il = cl->inherits;
@@ -694,7 +694,7 @@ _db_fill_inherits(const Eolian_Unit *src, Eolian_Class *cl, Eina_Hash *fhash)
         eina_stringshare_del(inn);
      }
 
-   eina_hash_add(fhash, cl->full_name, cl);
+   eina_hash_add(fhash, cl->base.name, cl);
 
    /* make sure impls/ctors are filled first, but do it only once */
    if (!_db_fill_implements(cl))
@@ -761,7 +761,7 @@ _validate_class(Validate_State *vals, const Eolian_Unit *src, Eolian_Class *cl,
                {
                   char buf[PATH_MAX];
                   snprintf(buf, sizeof(buf), "regular classes ('%s') cannot inherit from non-regular classes ('%s')",
-                           cl->full_name, icl->full_name);
+                           cl->base.name, icl->base.name);
                   return _obj_error(&cl->base, buf);
                }
              break;
@@ -771,7 +771,7 @@ _validate_class(Validate_State *vals, const Eolian_Unit *src, Eolian_Class *cl,
                {
                   char buf[PATH_MAX];
                   snprintf(buf, sizeof(buf), "non-regular classes ('%s') cannot inherit from regular classes ('%s')",
-                           cl->full_name, icl->full_name);
+                           cl->base.name, icl->base.name);
                   return _obj_error(&cl->base, buf);
                }
              break;
diff --git a/src/lib/eolian/database_var.c b/src/lib/eolian/database_var.c
index 4afc703277..36d22b3394 100644
--- a/src/lib/eolian/database_var.c
+++ b/src/lib/eolian/database_var.c
@@ -10,11 +10,11 @@ database_var_del(Eolian_Variable *var)
 {
    if (!var || eolian_object_unref(&var->base)) return;
    const char *sp;
-   if (var->base.file) eina_stringshare_del(var->base.file);
+   eina_stringshare_del(var->base.file);
+   eina_stringshare_del(var->base.name);
    if (var->base_type)
      database_type_del(var->base_type);
    if (var->name) eina_stringshare_del(var->name);
-   if (var->full_name) eina_stringshare_del(var->full_name);
    if (var->namespaces) EINA_LIST_FREE(var->namespaces, sp)
       eina_stringshare_del(sp);
    if (var->value) database_expr_del(var->value);
@@ -25,19 +25,19 @@ database_var_del(Eolian_Variable *var)
 static void
 database_var_global_add(Eolian_Unit *unit, Eolian_Variable *var)
 {
-   EOLIAN_OBJECT_ADD(unit, var->full_name, var, globals);
+   EOLIAN_OBJECT_ADD(unit, var->base.name, var, globals);
    eina_hash_set(unit->state->globals_f, var->base.file, eina_list_append
                  ((Eina_List*)eina_hash_find(unit->state->globals_f, var->base.file), var));
-   database_decl_add(unit, var->full_name, EOLIAN_DECL_VAR, var->base.file, var);
+   database_decl_add(unit, var->base.name, EOLIAN_DECL_VAR, var->base.file, var);
 }
 
 static void
 database_var_constant_add(Eolian_Unit *unit, Eolian_Variable *var)
 {
-    EOLIAN_OBJECT_ADD(unit, var->full_name, var, constants);
+    EOLIAN_OBJECT_ADD(unit, var->base.name, var, constants);
    eina_hash_set(unit->state->constants_f, var->base.file, eina_list_append
                  ((Eina_List*)eina_hash_find(unit->state->constants_f, var->base.file), var));
-   database_decl_add(unit, var->full_name, EOLIAN_DECL_VAR, var->base.file, var);
+   database_decl_add(unit, var->base.name, EOLIAN_DECL_VAR, var->base.file, var);
 }
 
 void
diff --git a/src/lib/eolian/database_var_api.c b/src/lib/eolian/database_var_api.c
index cde46b9a0a..208e339de9 100644
--- a/src/lib/eolian/database_var_api.c
+++ b/src/lib/eolian/database_var_api.c
@@ -51,7 +51,7 @@ EAPI Eina_Stringshare *
 eolian_variable_full_name_get(const Eolian_Variable *var)
 {
    EINA_SAFETY_ON_NULL_RETURN_VAL(var, NULL);
-   return var->full_name;
+   return var->base.name;
 }
 
 EAPI Eina_Iterator *
diff --git a/src/lib/eolian/eo_lexer.c b/src/lib/eolian/eo_lexer.c
index 9c4f751850..bad3e352ba 100644
--- a/src/lib/eolian/eo_lexer.c
+++ b/src/lib/eolian/eo_lexer.c
@@ -401,7 +401,7 @@ doc_lex(Eo_Lexer *ls, Eina_Bool *term, Eina_Bool *since)
           {
              next_char(ls);
              if (isalpha(ls->current) || ls->current == '_')
-               eina_strbuf_append(ls->buff, ls->tmp.kls->full_name);
+               eina_strbuf_append(ls->buff, ls->tmp.kls->base.name);
              eina_strbuf_append_char(ls->buff, '.');
           }
         continue;
diff --git a/src/lib/eolian/eo_parser.c b/src/lib/eolian/eo_parser.c
index 7c8003d0f7..481026ff5a 100644
--- a/src/lib/eolian/eo_parser.c
+++ b/src/lib/eolian/eo_parser.c
@@ -177,10 +177,10 @@ redef_error(Eo_Lexer *ls, Eolian_Declaration *decl, Eolian_Declaration_Type newt
 
    if (newt != decl->type)
      snprintf(buf, sizeof(buf), "%s '%s' redefined as %s (originally at %s)",
-              declnames[decl->type], decl->name, declnames[newt], fbuf);
+              declnames[decl->type], decl->base.name, declnames[newt], fbuf);
    else
      snprintf(buf, sizeof(buf), "%s '%s' redefined (originally at %s)",
-              declnames[decl->type], decl->name, fbuf);
+              declnames[decl->type], decl->base.name, fbuf);
 
    eo_lexer_syntax_error(ls, buf);
 }
@@ -478,8 +478,8 @@ parse_type(Eo_Lexer *ls)
 static void
 _struct_field_free(Eolian_Struct_Type_Field *def)
 {
-   if (def->base.file) eina_stringshare_del(def->base.file);
-   if (def->name) eina_stringshare_del(def->name);
+   eina_stringshare_del(def->base.file);
+   eina_stringshare_del(def->base.name);
    database_type_del(def->type);
    database_doc_del(def->doc);
    free(def);
@@ -492,7 +492,7 @@ parse_struct(Eo_Lexer *ls, const char *name, Eina_Bool is_extern,
    int bline = ls->line_number, bcolumn = ls->column;
    Eolian_Typedecl *def = push_typedecl(ls);
    def->is_extern = is_extern;
-   if (name) _fill_name(name, &def->full_name, &def->name, &def->namespaces);
+   if (name) _fill_name(name, &def->base.name, &def->name, &def->namespaces);
    def->type = EOLIAN_TYPEDECL_STRUCT;
    def->fields = eina_hash_string_small_new(EINA_FREE_CB(_struct_field_free));
    def->freefunc = freefunc;
@@ -518,7 +518,7 @@ parse_struct(Eo_Lexer *ls, const char *name, Eina_Bool is_extern,
         tp = parse_type(ls);
         FILL_BASE(fdef->base, ls, fline, fcol, STRUCT_FIELD);
         fdef->type = tp;
-        fdef->name = eina_stringshare_ref(fname);
+        fdef->base.name = eina_stringshare_ref(fname);
         pop_type(ls);
         if ((fdef->type->owned = (ls->t.kw == KW_at_owned)))
           eo_lexer_get(ls);
@@ -534,8 +534,8 @@ parse_struct(Eo_Lexer *ls, const char *name, Eina_Bool is_extern,
 static void
 _enum_field_free(Eolian_Enum_Type_Field *def)
 {
-   if (def->base.file) eina_stringshare_del(def->base.file);
-   if (def->name) eina_stringshare_del(def->name);
+   eina_stringshare_del(def->base.file);
+   eina_stringshare_del(def->base.name);
    database_expr_del(def->value);
    database_doc_del(def->doc);
    free(def);
@@ -548,7 +548,7 @@ parse_enum(Eo_Lexer *ls, const char *name, Eina_Bool is_extern,
    int bline = ls->line_number, bcolumn = ls->column;
    Eolian_Typedecl *def = push_typedecl(ls);
    def->is_extern = is_extern;
-   _fill_name(name, &def->full_name, &def->name, &def->namespaces);
+   _fill_name(name, &def->base.name, &def->name, &def->namespaces);
    def->type = EOLIAN_TYPEDECL_ENUM;
    def->fields = eina_hash_string_small_new(EINA_FREE_CB(_enum_field_free));
    check_next(ls, '{');
@@ -585,7 +585,7 @@ parse_enum(Eo_Lexer *ls, const char *name, Eina_Bool is_extern,
         eo_lexer_get(ls);
         FILL_BASE(fdef->base, ls, fline, fcol, ENUM_FIELD);
         fdef->base_enum = def;
-        fdef->name = eina_stringshare_ref(fname);
+        fdef->base.name = eina_stringshare_ref(fname);
         if (ls->t.token != '=')
           {
              if (!prev_fl)
@@ -763,7 +763,7 @@ parse_type_void(Eo_Lexer *ls)
         if (eo_lexer_is_type_keyword(ls->t.kw))
           {
              def->btype = ls->t.kw - KW_byte + 1;
-             _fill_name(eina_stringshare_ref(ls->t.value.s), &def->full_name,
+             _fill_name(eina_stringshare_ref(ls->t.value.s), &def->base.name,
                         &def->name, &def->namespaces);
              eo_lexer_get(ls);
              if (tpid >= KW_accessor && tpid <= KW_future)
@@ -820,7 +820,7 @@ parse_type_void(Eo_Lexer *ls)
                   free(fnm);
                   def->type = EOLIAN_TYPE_CLASS;
                }
-             _fill_name(eina_stringshare_add(nm), &def->full_name, &def->name,
+             _fill_name(eina_stringshare_add(nm), &def->base.name, &def->name,
                         &def->namespaces);
              eo_lexer_context_pop(ls);
              pop_strbuf(ls);
@@ -848,8 +848,8 @@ parse_typedef(Eo_Lexer *ls)
    FILL_BASE(def->base, ls, ls->line_number, ls->column, TYPEDECL);
    parse_name(ls, buf);
    _fill_name(eina_stringshare_add(eina_strbuf_string_get(buf)),
-              &def->full_name, &def->name, &def->namespaces);
-   decl = (Eolian_Declaration *)eina_hash_find(ls->state->unit.decls, def->full_name);
+              &def->base.name, &def->name, &def->namespaces);
+   decl = (Eolian_Declaration *)eina_hash_find(ls->state->unit.decls, def->base.name);
    if (decl)
      {
         eo_lexer_context_restore(ls);
@@ -884,8 +884,8 @@ parse_variable(Eo_Lexer *ls, Eina_Bool global)
    FILL_BASE(def->base, ls, ls->line_number, ls->column, VARIABLE);
    parse_name(ls, buf);
    _fill_name(eina_stringshare_add(eina_strbuf_string_get(buf)),
-              &def->full_name, &def->name, &def->namespaces);
-   decl = (Eolian_Declaration *)eina_hash_find(ls->state->unit.decls, def->full_name);
+              &def->base.name, &def->name, &def->namespaces);
+   decl = (Eolian_Declaration *)eina_hash_find(ls->state->unit.decls, def->base.name);
    if (decl)
      {
         eo_lexer_context_restore(ls);
@@ -995,7 +995,7 @@ parse_param(Eo_Lexer *ls, Eina_List **params, Eina_Bool allow_inout,
      }
    else par->param_dir = EOLIAN_IN_PARAM;
    check(ls, TOK_VALUE);
-   par->name = eina_stringshare_ref(ls->t.value.s);
+   par->base.name = eina_stringshare_ref(ls->t.value.s);
    eo_lexer_get(ls);
    check_next(ls, ':');
    if (par->param_dir == EOLIAN_OUT_PARAM || par->param_dir == EOLIAN_INOUT_PARAM)
@@ -1132,7 +1132,7 @@ parse_accessor:
              _eolian_log_line(prop->base.file, line, col,
                               "%s doc without property doc for '%s.%s'",
                               is_get ? "getter" : "setter",
-                              ls->tmp.kls->full_name, prop->name);
+                              ls->tmp.kls->base.name, prop->base.name);
           }
      }
    if (is_get)
@@ -1253,8 +1253,8 @@ parse_property(Eo_Lexer *ls)
         eo_lexer_syntax_error(ls, "reserved keyword as property name");
         return;
      }
-   prop->name = eina_stringshare_ref(ls->t.value.s);
-   impl->full_name = eina_stringshare_printf("%s.%s", ls->tmp.kls->full_name, prop->name);
+   prop->base.name = eina_stringshare_ref(ls->t.value.s);
+   impl->base.name = eina_stringshare_printf("%s.%s", ls->tmp.kls->base.name, prop->base.name);
    eo_lexer_get(ls);
    for (;;) switch (ls->t.kw)
      {
@@ -1340,7 +1340,7 @@ parse_function_pointer(Eo_Lexer *ls)
 
    parse_name(ls, buf);
    _fill_name(eina_stringshare_add(eina_strbuf_string_get(buf)),
-           &def->full_name, &def->name, &def->namespaces);
+           &def->base.name, &def->name, &def->namespaces);
 
    pop_strbuf(ls);
 
@@ -1348,7 +1348,7 @@ parse_function_pointer(Eo_Lexer *ls)
    meth->klass = NULL;
    meth->type = EOLIAN_FUNCTION_POINTER;
    meth->get_scope = meth->set_scope = EOLIAN_SCOPE_PUBLIC;
-   meth->name = eina_stringshare_ref(def->name);
+   meth->base.name = eina_stringshare_ref(def->name);
 
    def->function_pointer = meth;
    eolian_object_ref(&meth->base);
@@ -1419,8 +1419,8 @@ parse_method(Eo_Lexer *ls)
         eo_lexer_syntax_error(ls, "reserved keyword as method name");
         return;
      }
-   meth->name = eina_stringshare_ref(ls->t.value.s);
-   impl->full_name = eina_stringshare_printf("%s.%s", ls->tmp.kls->full_name, meth->name);
+   meth->base.name = eina_stringshare_ref(ls->t.value.s);
+   impl->base.name = eina_stringshare_printf("%s.%s", ls->tmp.kls->base.name, meth->base.name);
    eo_lexer_get(ls);
    for (;;) switch (ls->t.kw)
      {
@@ -1501,7 +1501,7 @@ parse_part(Eo_Lexer *ls)
    ls->tmp.kls->parts = eina_list_append(ls->tmp.kls->parts, part);
    eolian_object_ref(&part->base);
    check(ls, TOK_VALUE);
-   part->name = eina_stringshare_ref(ls->t.value.s);
+   part->base.name = eina_stringshare_ref(ls->t.value.s);
    eo_lexer_get(ls);
    check_next(ls, ':');
    Eina_Strbuf *buf = push_strbuf(ls);
@@ -1572,12 +1572,12 @@ parse_implement(Eo_Lexer *ls, Eina_Bool iface)
         if (ls->t.token != TOK_VALUE)
           eo_lexer_syntax_error(ls, "name expected");
         Eina_Stringshare *iname = eina_stringshare_printf("%s.%s",
-                                                          ls->tmp.kls->full_name,
+                                                          ls->tmp.kls->base.name,
                                                           ls->t.value.s);
         Eina_List *l;
         Eolian_Implement *fimp;
         EINA_LIST_FOREACH(ls->tmp.kls->implements, l, fimp)
-          if (iname == fimp->full_name)
+          if (iname == fimp->base.name)
             {
                impl = fimp;
                break;
@@ -1688,7 +1688,7 @@ propend:
      }
    if (buf)
      {
-        impl->full_name = eina_stringshare_add(eina_strbuf_string_get(buf));
+        impl->base.name = eina_stringshare_add(eina_strbuf_string_get(buf));
         pop_strbuf(ls);
      }
 }
@@ -1707,8 +1707,8 @@ parse_constructor(Eo_Lexer *ls)
         check_next(ls, '.');
         if (ls->t.token != TOK_VALUE)
           eo_lexer_syntax_error(ls, "name expected");
-        ctor->full_name = eina_stringshare_printf("%s.%s",
-                                                  ls->tmp.kls->full_name,
+        ctor->base.name = eina_stringshare_printf("%s.%s",
+                                                  ls->tmp.kls->base.name,
                                                   ls->t.value.s);
         eo_lexer_get(ls);
         if (ls->t.kw == KW_at_optional)
@@ -1740,7 +1740,7 @@ parse_constructor(Eo_Lexer *ls)
         ctor->is_optional = EINA_TRUE;
      }
    check_next(ls, ';');
-   ctor->full_name = eina_stringshare_add(eina_strbuf_string_get(buf));
+   ctor->base.name = eina_stringshare_add(eina_strbuf_string_get(buf));
    pop_strbuf(ls);
 }
 
@@ -1764,7 +1764,7 @@ parse_event(Eo_Lexer *ls)
         eina_strbuf_append(buf, ls->t.value.s);
         eo_lexer_get(ls);
      }
-   ev->name = eina_stringshare_add(eina_strbuf_string_get(buf));
+   ev->base.name = eina_stringshare_add(eina_strbuf_string_get(buf));
    pop_strbuf(ls);
    Eina_Bool has_scope = EINA_FALSE, has_beta = EINA_FALSE,
              has_hot   = EINA_FALSE, has_restart = EINA_FALSE,
@@ -2071,9 +2071,9 @@ parse_class(Eo_Lexer *ls, Eolian_Class_Type type)
         eo_lexer_syntax_error(ls, "class and file names differ");
      }
    _fill_name(eina_stringshare_add(eina_strbuf_string_get(buf)),
-              &ls->tmp.kls->full_name, &ls->tmp.kls->name,
+              &ls->tmp.kls->base.name, &ls->tmp.kls->name,
               &ls->tmp.kls->namespaces);
-   decl = (Eolian_Declaration *)eina_hash_find(ls->state->unit.decls, ls->tmp.kls->full_name);
+   decl = (Eolian_Declaration *)eina_hash_find(ls->state->unit.decls, ls->tmp.kls->base.name);
    if (decl)
      {
         eo_lexer_context_restore(ls);
@@ -2205,7 +2205,7 @@ parse_unit(Eo_Lexer *ls, Eina_Bool eot)
                 def->type = EOLIAN_TYPEDECL_STRUCT_OPAQUE;
                 def->freefunc = freefunc;
                 pop_str(ls);
-                _fill_name(name, &def->full_name, &def->name, &def->namespaces);
+                _fill_name(name, &def->base.name, &def->name, &def->namespaces);
                 eo_lexer_get(ls);
                 FILL_DOC(ls, def, doc);
                 FILL_BASE(def->base, ls, line, col, TYPEDECL);
@@ -2227,7 +2227,7 @@ parse_unit(Eo_Lexer *ls, Eina_Bool eot)
      }
    return EINA_FALSE;
 found_class:
-   database_decl_add(ls->unit, ls->tmp.kls->full_name, EOLIAN_DECL_CLASS,
+   database_decl_add(ls->unit, ls->tmp.kls->base.name, EOLIAN_DECL_CLASS,
                      ls->tmp.kls->base.file, ls->tmp.kls);
    return EINA_TRUE;
 }
@@ -2286,7 +2286,7 @@ eo_parser_database_fill(Eolian_Unit *parent, const char *filename, Eina_Bool eot
      }
    ls->tmp.kls = NULL;
 
-   EOLIAN_OBJECT_ADD(ls->unit, cl->full_name, cl, classes);
+   EOLIAN_OBJECT_ADD(ls->unit, cl->base.name, cl, classes);
    eina_hash_set(ls->state->classes_f, cl->base.file, cl);
 
 done:
diff --git a/src/lib/eolian/eolian_database.c b/src/lib/eolian/eolian_database.c
index e9bfd98066..4c3b4ff797 100644
--- a/src/lib/eolian/eolian_database.c
+++ b/src/lib/eolian/eolian_database.c
@@ -16,9 +16,9 @@ database_decl_add(Eolian_Unit *unit, Eina_Stringshare *name,
    Eolian_Declaration *decl = calloc(1, sizeof(Eolian_Declaration));
    decl->base = *((Eolian_Object *)ptr);
    decl->base.file = eina_stringshare_ref(decl->base.file);
+   decl->base.name = eina_stringshare_ref(decl->base.name);
    decl->base.refcount = 0;
    decl->type = type;
-   decl->name = name;
    decl->data = ptr;
    EOLIAN_OBJECT_ADD(unit, name, decl, decls);
    eina_hash_set(unit->state->decls_f, file, eina_list_append
@@ -35,6 +35,7 @@ database_decl_del(Eolian_Declaration *decl)
 {
    if (!decl || eolian_object_unref(&decl->base)) return;
    eina_stringshare_del(decl->base.file);
+   eina_stringshare_del(decl->base.name);
    free(decl);
 }
 
@@ -76,7 +77,7 @@ EAPI Eina_Stringshare *
 eolian_declaration_name_get(const Eolian_Declaration *decl)
 {
    EINA_SAFETY_ON_NULL_RETURN_VAL(decl, NULL);
-   return decl->name;
+   return decl->base.name;
 }
 
 EAPI const Eolian_Class *
@@ -639,6 +640,13 @@ eolian_object_column_get(const Eolian_Object *obj)
    return obj->column;
 }
 
+EAPI const char *
+eolian_object_name_get(const Eolian_Object *obj)
+{
+   if (!obj) return NULL;
+   return obj->name;
+}
+
 #define EO_SUFFIX ".eo"
 #define EOT_SUFFIX ".eot"
 
diff --git a/src/lib/eolian/eolian_database.h b/src/lib/eolian/eolian_database.h
index aac5cde699..526fba070a 100644
--- a/src/lib/eolian/eolian_database.h
+++ b/src/lib/eolian/eolian_database.h
@@ -68,7 +68,8 @@ struct _Eolian_State
 
 struct _Eolian_Object
 {
-   const char *file;
+   Eina_Stringshare *file;
+   Eina_Stringshare *name;
    int line;
    int column;
    int refcount;
@@ -113,14 +114,12 @@ struct _Eolian_Declaration
 {
    Eolian_Object base;
    Eolian_Declaration_Type type;
-   Eina_Stringshare *name;
    void *data;
 };
 
 struct _Eolian_Class
 {
    Eolian_Object base;
-   Eina_Stringshare *full_name;
    Eina_List *namespaces; /* List Eina_Stringshare * */
    Eina_Stringshare *name;
    Eolian_Class_Type type;
@@ -144,7 +143,6 @@ struct _Eolian_Function
 {
    Eolian_Object base;
    Eolian_Object set_base;
-   Eina_Stringshare *name;
    union { /* lists of Eolian_Function_Parameter */
        Eina_List *params;
        struct {
@@ -182,7 +180,6 @@ struct _Eolian_Function
 struct _Eolian_Part
 {
    Eolian_Object base;
-   Eina_Stringshare *name;
    /* when not validated, class name is stored */
    union
    {
@@ -195,7 +192,6 @@ struct _Eolian_Part
 struct _Eolian_Function_Parameter
 {
    Eolian_Object base;
-   Eina_Stringshare *name;
    Eolian_Type *type;
    Eolian_Expression *value;
    Eolian_Documentation *doc;
@@ -213,7 +209,6 @@ struct _Eolian_Type
    Eolian_Type *base_type;
    Eolian_Type *next_type;
    Eina_Stringshare *name;
-   Eina_Stringshare *full_name;
    Eina_List        *namespaces;
    Eina_Stringshare *freefunc;
    union
@@ -233,7 +228,6 @@ struct _Eolian_Typedecl
    Eolian_Typedecl_Type type;
    Eolian_Type      *base_type;
    Eina_Stringshare *name;
-   Eina_Stringshare *full_name;
    Eina_List        *namespaces;
    Eina_Hash        *fields;
    Eina_List        *field_list;
@@ -249,7 +243,6 @@ struct _Eolian_Implement
    Eolian_Object base;
    const Eolian_Class *klass;
    const Eolian_Function *foo_id;
-   Eina_Stringshare *full_name;
    Eolian_Documentation *common_doc;
    Eolian_Documentation *get_doc;
    Eolian_Documentation *set_doc;
@@ -267,14 +260,12 @@ struct _Eolian_Constructor
 {
    Eolian_Object base;
    const Eolian_Class *klass;
-   Eina_Stringshare *full_name;
    Eina_Bool is_optional: 1;
 };
 
 struct _Eolian_Event
 {
    Eolian_Object base;
-   Eina_Stringshare *name;
    Eolian_Documentation *doc;
    Eolian_Type *type;
    Eolian_Class *klass;
@@ -287,7 +278,6 @@ struct _Eolian_Event
 struct _Eolian_Struct_Type_Field
 {
    Eolian_Object     base;
-   Eina_Stringshare *name;
    Eolian_Type      *type;
    Eolian_Documentation *doc;
 };
@@ -296,7 +286,6 @@ struct _Eolian_Enum_Type_Field
 {
    Eolian_Object      base;
    Eolian_Typedecl   *base_enum;
-   Eina_Stringshare  *name;
    Eolian_Expression *value;
    Eolian_Documentation *doc;
    Eina_Bool is_public_value :1;
@@ -333,7 +322,6 @@ struct _Eolian_Variable
    Eolian_Object         base;
    Eolian_Variable_Type  type;
    Eina_Stringshare     *name;
-   Eina_Stringshare     *full_name;
    Eina_List            *namespaces;
    Eolian_Type          *base_type;
    Eolian_Expression    *value;