eolian: make inherits_get return a list of classes, not strings

Most of the time you need to retrieve the class from the string
anyway, so remove this relic of old Eolian and gain some small
performance benefits and extra convenience.

Subtly breaks API but everything should be updated.

src/bin/eolian/sources.c

@@ -965,14 +965,13 @@ eo_gen_source_gen(const Eolian_Unit *src,
 
    /* inherits in EFL_DEFINE_CLASS */
    {
-      const char *iname;
+      const Eolian_Class *icl;
       Eina_Iterator *itr = eolian_class_inherits_get(cl);
       /* no inherits, NULL parent */
       if (!itr)
         eina_strbuf_append(buf, ", NULL");
-      EINA_ITERATOR_FOREACH(itr, iname)
+      EINA_ITERATOR_FOREACH(itr, icl)
         {
-           const Eolian_Class *icl = eolian_class_get_by_name(src, iname);
            Eina_Stringshare *mname = eolian_class_c_name_get(icl);
            eina_strbuf_append_printf(buf, ", %s", mname);
            eina_stringshare_del(mname);

src/bin/eolian_cxx/eolian_cxx.cc

@@ -114,10 +114,10 @@ generate(const Eolian_Class* klass, eolian_cxx::options_type const& opts)
    std::function<void(Eolian_Class const*)> klass_function
      = [&] (Eolian_Class const* klass)
      {
-       for(efl::eina::iterator<const char> inherit_iterator ( ::eolian_class_inherits_get(klass))
+       for(efl::eina::iterator<Eolian_Class const> inherit_iterator ( ::eolian_class_inherits_get(klass))
              , inherit_last; inherit_iterator != inherit_last; ++inherit_iterator)
          {
-           Eolian_Class const* inherit = ::eolian_class_get_by_name(opts.unit, &*inherit_iterator);
+           Eolian_Class const* inherit = &*inherit_iterator;
            c_headers.insert(eolian_class_file_get(inherit) + std::string(".h"));
            cpp_headers.insert(eolian_class_file_get(inherit) + std::string(".hh"));
            efl::eolian::grammar::attributes::klass_def klass{inherit, opts.unit};

src/bindings/luajit/eolian.lua

@@ -1239,7 +1239,7 @@ M.Class = ffi.metatype("Eolian_Class", {
         end,
 
         inherits_get = function(self)
-            return iterator.String_Iterator(
+            return Ptr_Iterator("const Eolian_Class*",
                 eolian.eolian_class_inherits_get(self))
         end,
 

src/lib/eolian/Eolian.h

@@ -709,7 +709,7 @@ EAPI Eina_Stringshare* eolian_class_event_prefix_get(const Eolian_Class *klass);
 EAPI Eina_Stringshare *eolian_class_data_type_get(const Eolian_Class *klass);
 
 /*
- * @brief Returns an iterator to the names of inherit classes of a class
+ * @brief Returns an iterator to the inherited classes.
  *
  * @param[in] klass the class
  * @return the iterator

src/lib/eolian/database_class.c

@@ -18,9 +18,6 @@ database_class_del(Eolian_Class *cl)
 
    if (cl->base.file) eina_stringshare_del(cl->base.file);
 
-   EINA_LIST_FREE(cl->inherits, s)
-     if (s) eina_stringshare_del(s);
-
    EINA_LIST_FREE(cl->implements, impl)
      database_implement_del(impl);
 

src/lib/eolian/database_validate.c

@@ -373,7 +373,7 @@ _validate_class(Eolian_Class *cl, Eina_Hash *nhash)
    Eolian_Function *func;
    Eolian_Event *event;
    Eolian_Implement *impl;
-   const char *iname;
+   Eolian_Class *icl;
    Eina_Bool res = EINA_TRUE;
 
    if (!cl)
@@ -386,9 +386,9 @@ _validate_class(Eolian_Class *cl, Eina_Hash *nhash)
    if (ahash)
      nhash = eina_hash_string_small_new(NULL);
 
-   EINA_LIST_FOREACH(cl->inherits, l, iname)
+   EINA_LIST_FOREACH(cl->inherits, l, icl)
      {
-        if (!(res = _validate_class(eina_hash_find(_classes, iname), nhash)))
+        if (!(res = _validate_class(icl, nhash)))
           goto freehash;
      }
 

src/lib/eolian/eo_parser.c

@@ -2021,8 +2021,7 @@ _inherit_dep(Eo_Lexer *ls, Eina_Strbuf *buf, Eina_Bool check_inherit,
       default:
         break;
      }
-   ls->tmp.kls->inherits = eina_list_append(ls->tmp.kls->inherits,
+   ls->tmp.kls->inherits = eina_list_append(ls->tmp.kls->inherits, dep);
-                                            eina_stringshare_add(iname));
    dep->toplevel = EINA_FALSE;
    eo_lexer_context_pop(ls);
 }
@@ -2245,14 +2244,13 @@ _get_impl_class(const Eolian_Class *cl, const char *cln)
    if (!cl || !strcmp(cl->full_name, cln))
      return cl;
    Eina_List *l;
-   const char *s;
+   Eolian_Class *icl;
-   EINA_LIST_FOREACH(cl->inherits, l, s)
+   EINA_LIST_FOREACH(cl->inherits, l, icl)
      {
         /* we can do a depth first search, it's easier and doesn't matter
          * which part of the inheritance tree we find the class in
          */
-        /* FIXME: pass unit properly */
+        const Eolian_Class *fcl = _get_impl_class(icl, cln);
-        const Eolian_Class *fcl = _get_impl_class(eolian_class_get_by_name(NULL, s), cln);
         if (fcl)
           return fcl;
      }

src/lib/eolian/eolian_database.h

@@ -91,7 +91,7 @@ struct _Eolian_Class
    Eina_Stringshare *eo_prefix;
    Eina_Stringshare *ev_prefix;
    Eina_Stringshare *data_type;
-   Eina_List *inherits; /* List Eina_Stringshare * */
+   Eina_List *inherits; /* List Eolian_Class * */
    Eina_List *properties; /* List prop_name -> Eolian_Function */
    Eina_List *methods; /* List meth_name -> Eolian_Function */
    Eina_List *implements; /* List implements name -> Eolian_Implement */

src/lib/eolian_cxx/grammar/klass_def.hpp

@@ -687,10 +687,10 @@ struct klass_def
      std::function<void(Eolian_Class const*)> inherit_algo = 
        [&] (Eolian_Class const* klass)
        {
-         for(efl::eina::iterator<const char> inherit_iterator ( ::eolian_class_inherits_get(klass))
+         for(efl::eina::iterator<Eolian_Class const> inherit_iterator ( ::eolian_class_inherits_get(klass))
                , inherit_last; inherit_iterator != inherit_last; ++inherit_iterator)
            {
-             Eolian_Class const* inherit = ::eolian_class_get_by_name(unit, &*inherit_iterator);
+             Eolian_Class const* inherit = &*inherit_iterator;
              inherits.insert({inherit, {}});
              inherit_algo(inherit);
            }

src/scripts/elua/apps/docgen/doctree.lua

@@ -223,9 +223,7 @@ M.Class = Node:clone {
             return ret
         end
         ret = {}
-        for cln in self.class:inherits_get() do
+        for cl in self.class:inherits_get() do
-            local cl = self.by_name_get(cln)
-            assert(cl)
             ret[#ret + 1] = cl
         end
         self._cache_inhc = ret

src/scripts/elua/modules/lualian.lua

@@ -670,8 +670,7 @@ local gen_class = function(klass)
     local parents = {}
     local mixins  = {} -- also includes ifaces, they're separated later
     for i = 1, #inherits do
-        local v = inherits[i]
+        local tp = inherits[i]:type_get()
-        local tp = eolian.class_get_by_name(gen_unit, v):type_get()
         if tp == class_type.REGULAR or tp == class_type.ABSTRACT then
             parents[#parents + 1] = v
         elseif tp == class_type.INTERFACE or tp == class_type.MIXIN then

src/tests/eolian/eolian_parsing.c

@@ -12,11 +12,12 @@
 
 START_TEST(eolian_namespaces)
 {
-   const Eolian_Class *class11, *class112, *class21, *class_no, *impl_class;
+   const Eolian_Class *class11, *class112, *class21, *class_no, *impl_class,
+                      *iclass;
    const Eolian_Function *fid;
    Eina_Iterator *iter;
    Eolian_Function_Type func_type;
-   const char *class_name, *val1, *val2;
+   const char *val1, *val2;
    const Eolian_Implement *impl;
    const Eolian_Unit *unit;
    void *dummy;
@@ -61,12 +62,12 @@ START_TEST(eolian_namespaces)
 
    /* Inherits */
    fail_if(!(iter = eolian_class_inherits_get(class11)));
-   fail_if(!(eina_iterator_next(iter, (void**)&class_name)));
+   fail_if(!(eina_iterator_next(iter, (void**)&iclass)));
-   fail_if(eolian_class_get_by_name(unit, class_name) != class112);
+   fail_if(iclass != class112);
-   fail_if(!(eina_iterator_next(iter, (void**)&class_name)));
+   fail_if(!(eina_iterator_next(iter, (void**)&iclass)));
-   fail_if(eolian_class_get_by_name(unit, class_name) != class21);
+   fail_if(iclass != class21);
-   fail_if(!(eina_iterator_next(iter, (void**)&class_name)));
+   fail_if(!(eina_iterator_next(iter, (void**)&iclass)));
-   fail_if(eolian_class_get_by_name(unit, class_name) != class_no);
+   fail_if(iclass != class_no);
    fail_if(eina_iterator_next(iter, &dummy));
    eina_iterator_free(iter);