efl-csharp: Respect beta for classes and other stuff.

Summary:
In order to work around an issue with Efl.App, which is stable but
inherits from Efl.Core.Command_Line, @beta interfaces/mixins in the
inheritance chain are simply skipped.

Also changed the class used int test for inheritance from C#

Efl.Loop is stable but internally it uses a @beta class as argument to
its Register() method in the constructor. When instantiating a
user-defined C# subclass, the binding calls the C# override in the
NativeInherit class and the marshalling fails as no code is generated
for the beta class.

Also moved Efl.Part test to a beta class. Efl.Part is still beta.

Regarding parts, they are skipped if its class is @beta too.

Also rejected all elm_* files in elm public eo files. They should get
back in as they are converted to Efl.Ui.* api. An exception is
elm_interface_scrollable.eo, as efl_ui_panel depends on it.

Fixes T7730

Test Plan: Run tests

Reviewers: vitor.sousa, segfaultxavi, felipealmeida, cedric, bu5hm4n, zmike

Reviewed By: vitor.sousa

Subscribers: #reviewers, #committers

Tags: #efl

Maniphest Tasks: T7730

Differential Revision: https://phab.enlightenment.org/D8268

7 files changed, 86 insertions, 14 deletions

diff --git a/src/bin/eolian_mono/eolian/mono/blacklist.hh b/src/bin/eolian_mono/eolian/mono/blacklist.hh
index c11437b..2b9d8ad 100644
--- a/src/bin/eolian_mono/eolian/mono/blacklist.hh
+++ b/src/bin/eolian_mono/eolian/mono/blacklist.hh
@@ -67,6 +67,7 @@ inline bool is_function_blacklisted(attributes::function_def const& func, Contex
 // Blacklist structs that require some kind of manual binding.
 inline bool is_struct_blacklisted(std::string const& full_name)
 {
+   // For now, these manual structs are blacklisted regardless of beta status
    return full_name == "Efl.Event_Description"
        || full_name == "Eina.Binbuf"
        || full_name == "Eina.Strbuf"
@@ -78,11 +79,28 @@ inline bool is_struct_blacklisted(std::string const& full_name)
        || full_name == "Eina.Future";
 }
 
-inline bool is_struct_blacklisted(attributes::struct_def const& struct_)
+template <typename Context>
+inline bool is_struct_blacklisted(attributes::struct_def const& struct_, Context context)
 {
+   auto options = efl::eolian::grammar::context_find_tag<options_context>(context);
+   if (struct_.is_beta && !options.want_beta)
+     return true;
+
    return is_struct_blacklisted(name_helpers::struct_full_eolian_name(struct_));
 }
 
+// Struct as type_def is for places where the struct is used as a struct field or parameter/return.
+template <typename Context>
+inline bool is_struct_blacklisted(attributes::type_def const& struct_, Context context)
+{
+   auto options = efl::eolian::grammar::context_find_tag<options_context>(context);
+   if (struct_.is_beta && !options.want_beta)
+     return true;
+
+   auto regular = efl::eina::get<attributes::regular_type_def>(struct_.original_type);
+   return is_struct_blacklisted(name_helpers::type_full_eolian_name(regular));
+}
+
 inline bool is_struct_blacklisted(attributes::regular_type_def const& struct_)
 {
    return is_struct_blacklisted(name_helpers::type_full_eolian_name(struct_));
@@ -114,6 +132,31 @@ inline bool is_property_blacklisted(attributes::property_def const& property, Co
     return is_property_blacklisted(name);
 }
 
+template<typename Context>
+inline bool is_class_blacklisted(attributes::klass_def const& cls, Context context)
+{
+   auto options = efl::eolian::grammar::context_find_tag<options_context>(context);
+
+   return cls.is_beta && !options.want_beta;
+}
+
+template<typename Context>
+inline bool is_class_blacklisted(attributes::klass_name const& cls, Context context)
+{
+   auto options = efl::eolian::grammar::context_find_tag<options_context>(context);
+
+   return cls.is_beta && !options.want_beta;
+}
+
+
+template<typename Context>
+inline bool is_event_blacklisted(attributes::event_def const& evt, Context context)
+{
+   auto options = efl::eolian::grammar::context_find_tag<options_context>(context);
+
+   return evt.beta && !options.want_beta;
+}
+
 }
 
 }
diff --git a/src/bin/eolian_mono/eolian/mono/events.hh b/src/bin/eolian_mono/eolian/mono/events.hh
index 76e82bd..d8dc043 100644
--- a/src/bin/eolian_mono/eolian/mono/events.hh
+++ b/src/bin/eolian_mono/eolian/mono/events.hh
@@ -93,6 +93,9 @@ struct event_argument_wrapper_generator
       if (!etype.is_engaged())
         return true;
 
+      if (blacklist::is_event_blacklisted(evt, context))
+        return true;
+
       std::string evt_name = name_helpers::managed_event_name(evt.name);
 
       return as_generator("///<summary>Event argument wrapper for event <see cref=\""
@@ -119,6 +122,9 @@ struct event_declaration_generator
       std::string wrapper_args_type;
       std::string evt_name = name_helpers::managed_event_name(evt.name);
 
+      if (blacklist::is_event_blacklisted(evt, context))
+        return true;
+
       if (evt.type.is_engaged())
         wrapper_args_type = "<" + name_helpers::managed_event_args_name(evt) + ">";
 
@@ -143,6 +149,9 @@ struct event_registration_generator
    {
        std::string wrapper_event_name;
 
+      if (blacklist::is_event_blacklisted(evt, context))
+        return true;
+
        if (is_inherited_event && !helpers::is_unique_event(evt, leaf_klass))
             wrapper_event_name = name_helpers::translate_inherited_event_name(evt, klass);
        else
@@ -172,6 +181,9 @@ struct event_definition_generator
    template<typename OutputIterator, typename Context>
    bool generate(OutputIterator sink, attributes::event_def const& evt, Context context) const
    {
+      if (blacklist::is_event_blacklisted(evt, context))
+        return true;
+
       std::string managed_evt_name = name_helpers::managed_event_name(evt.name);
 
       bool is_unique = helpers::is_unique_event(evt, leaf_klass);
diff --git a/src/bin/eolian_mono/eolian/mono/function_pointer.hh b/src/bin/eolian_mono/eolian/mono/function_pointer.hh
index a7e692b..f3918f1 100644
--- a/src/bin/eolian_mono/eolian/mono/function_pointer.hh
+++ b/src/bin/eolian_mono/eolian/mono/function_pointer.hh
@@ -9,15 +9,17 @@
 #include "function_helpers.hh"
 #include "documentation.hh"
 #include "generation_contexts.hh"
+#include "blacklist.hh"
 
 namespace eolian_mono {
 
 // Blacklist structs that require some kind of manual binding.
-static bool is_function_ptr_blacklisted(attributes::function_def const& func)
+template <typename Context>
+static bool is_function_ptr_blacklisted(attributes::function_def const& func, Context context)
 {
   std::string name = name_helpers::function_ptr_full_eolian_name(func);
 
-  return false;
+  return blacklist::is_function_blacklisted(func, context);
 }
 
 struct function_pointer {
@@ -28,13 +30,13 @@ struct function_pointer {
       // FIXME export Typedecl in eolian_cxx API
       auto funcptr_ctx = context_add_tag(class_context{class_context::function_ptr}, context);
 
+      if (is_function_ptr_blacklisted(f, context))
+        return true;
+
       std::string return_type;
       if(!as_generator(eolian_mono::type(true)).generate(std::back_inserter(return_type), f.return_type, context))
         return false;
 
-      if (is_function_ptr_blacklisted(f))
-        return true;
-
       if (!name_helpers::open_namespaces(sink, f.namespaces, funcptr_ctx))
         return false;
 
diff --git a/src/bin/eolian_mono/eolian/mono/helpers.hh b/src/bin/eolian_mono/eolian/mono/helpers.hh
index 87a1e9d..a4bb169 100644
--- a/src/bin/eolian_mono/eolian/mono/helpers.hh
+++ b/src/bin/eolian_mono/eolian/mono/helpers.hh
@@ -102,8 +102,10 @@ std::set<attributes::klass_name, attributes::compare_klass_name_by_name> interfa
 
 // Returns the set of interfaces implemented by this type that haven't been implemented
 // by a regular parent class.
-std::set<attributes::klass_name, attributes::compare_klass_name_by_name> non_implemented_interfaces(attributes::klass_def const& cls)
+template<typename Context>
+std::set<attributes::klass_name, attributes::compare_klass_name_by_name> non_implemented_interfaces(attributes::klass_def const& cls, Context context)
 {
+   auto options = efl::eolian::grammar::context_find_tag<options_context>(context);
    std::set<attributes::klass_name, attributes::compare_klass_name_by_name> implemented_interfaces;
    std::set<attributes::klass_name, attributes::compare_klass_name_by_name> interfaces;
 
@@ -114,6 +116,9 @@ std::set<attributes::klass_name, attributes::compare_klass_name_by_name> non_imp
           attributes::klass_def c(get_klass(klass, cls.unit), cls.unit);
           for(auto&& inherit : c.immediate_inherits)
             {
+               if (inherit.is_beta && !options.want_beta)
+                   continue;
+
                switch(inherit.type)
                  {
                  case attributes::class_type::mixin:
diff --git a/src/bin/eolian_mono/eolian/mono/klass.hh b/src/bin/eolian_mono/eolian/mono/klass.hh
index 0689648..a9f270d 100644
--- a/src/bin/eolian_mono/eolian/mono/klass.hh
+++ b/src/bin/eolian_mono/eolian/mono/klass.hh
@@ -95,6 +95,13 @@ struct klass
    bool generate(OutputIterator sink, attributes::klass_def const& cls, Context const& context) const
    {
      EINA_CXX_DOM_LOG_DBG(eolian_mono::domain) << "klass_generator: " << cls.eolian_name << std::endl;
+
+     if (blacklist::is_class_blacklisted(cls, context))
+       {
+          EINA_CXX_DOM_LOG_DBG(eolian_mono::domain) << "class " << cls.eolian_name << " is blacklisted. Skipping." << std::endl;
+          return true;
+       }
+
      std::string suffix, class_type;
      switch(cls.type)
        {
@@ -183,7 +190,7 @@ struct klass
        return false;
 
      bool root = !helpers::has_regular_ancestor(cls);
-     std::set<attributes::klass_name, attributes::compare_klass_name_by_name> inherit_interfaces = helpers::non_implemented_interfaces(cls);
+     std::set<attributes::klass_name, attributes::compare_klass_name_by_name> inherit_interfaces = helpers::non_implemented_interfaces(cls, context);
      std::vector<attributes::klass_name> inherit_classes;
      std::copy_if(cls.immediate_inherits.begin(), cls.immediate_inherits.end()
                   , std::back_inserter(inherit_classes)
@@ -268,7 +275,7 @@ struct klass
          if (!as_generator(*(property_wrapper_definition)).generate(sink, cls.properties, concrete_cxt))
            return false;
 
-         for (auto&& klass : helpers::non_implemented_interfaces(cls))
+         for (auto&& klass : helpers::non_implemented_interfaces(cls, concrete_cxt))
            {
               attributes::klass_def c(get_klass(klass, cls.unit), cls.unit);
               if (!as_generator(*(property_wrapper_definition)).generate(sink, c.properties, concrete_cxt))
@@ -340,7 +347,7 @@ struct klass
          if (!as_generator(*(property_wrapper_definition)).generate(sink, cls.properties, inherit_cxt))
            return false;
 
-         for (auto&& klass : helpers::non_implemented_interfaces(cls))
+         for (auto&& klass : helpers::non_implemented_interfaces(cls, inherit_cxt))
            {
               attributes::klass_def c(get_klass(klass, cls.unit), cls.unit);
               if (!as_generator(*(property_wrapper_definition)).generate(sink, c.properties, inherit_cxt))
@@ -644,7 +651,7 @@ struct klass
      if (!as_generator(*(event_registration(cls, cls))).generate(sink, cls.events, context))
        return false;
 
-     for (auto&& c : helpers::non_implemented_interfaces(cls))
+     for (auto&& c : helpers::non_implemented_interfaces(cls, context))
        {
           // Only non-regular types (which declare events through interfaces) need to register them.
           if (c.type == attributes::class_type::regular)
@@ -742,7 +749,7 @@ struct klass
      // Inherited events
 
      // For now, as mixins can inherit from regular classes, we can't filter out inherited events.
-     auto inherits = helpers::non_implemented_interfaces(cls);
+     auto inherits = helpers::non_implemented_interfaces(cls, context);
      for (auto&& c : inherits)
        {
           attributes::klass_def klass(get_klass(c, cls.unit), cls.unit);
diff --git a/src/bin/eolian_mono/eolian/mono/part_definition.hh b/src/bin/eolian_mono/eolian/mono/part_definition.hh
index 47951f4..2a8d2e1 100644
--- a/src/bin/eolian_mono/eolian/mono/part_definition.hh
+++ b/src/bin/eolian_mono/eolian/mono/part_definition.hh
@@ -18,6 +18,9 @@ struct part_definition_generator
   template <typename OutputIterator, typename Context>
   bool generate(OutputIterator sink, attributes::part_def const& part, Context const& context) const
   {
+     if (blacklist::is_class_blacklisted(part.klass, context))
+       return true;
+
      auto part_klass_name = name_helpers::klass_full_concrete_or_interface_name(part.klass);
      return as_generator(scope_tab << documentation
                        << scope_tab << "public " << part_klass_name << " " << name_helpers::managed_part_name(part) << "\n"
diff --git a/src/bin/eolian_mono/eolian/mono/struct_definition.hh b/src/bin/eolian_mono/eolian/mono/struct_definition.hh
index 17485d1..ba058d0 100644
--- a/src/bin/eolian_mono/eolian/mono/struct_definition.hh
+++ b/src/bin/eolian_mono/eolian/mono/struct_definition.hh
@@ -196,6 +196,7 @@ struct to_internal_field_convert_generator
    bool generate(OutputIterator sink, attributes::struct_field_def const& field, Context const& context) const
    {
       auto field_name = name_helpers::to_field_name(field.name);
+      // FIXME Replace need_struct_conversion(regular) with need_struct_conversion(type)
       auto regular = efl::eina::get<attributes::regular_type_def>(&field.type.original_type);
       auto klass = efl::eina::get<attributes::klass_name>(&field.type.original_type);
       auto complex = efl::eina::get<attributes::complex_type_def>(&field.type.original_type);
@@ -496,10 +497,9 @@ struct struct_entities_generator
   template <typename OutputIterator, typename Context>
   bool generate(OutputIterator sink, attributes::struct_def const& struct_, Context const& context) const
   {
-     if (blacklist::is_struct_blacklisted(struct_))
+     if (blacklist::is_struct_blacklisted(struct_, context))
        return true;
 
-
      if (!name_helpers::open_namespaces(sink, struct_.namespaces, context))
        return false;