eolian_cxx: Add support for @by_ref

Summary:
It will coexist with `eolian_type_is_ptr` while we phase out the latter.

Fixes: T8211

Depends on D9866

Reviewers: q66, felipealmeida

Reviewed By: q66

Subscribers: cedric, #reviewers, #committers

Tags: #efl

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

2 files changed, 56 insertions, 20 deletions

diff --git a/src/lib/eolian_cxx/grammar/klass_def.hpp b/src/lib/eolian_cxx/grammar/klass_def.hpp
index fbd8779e0f..4de294e836 100644
--- a/src/lib/eolian_cxx/grammar/klass_def.hpp
+++ b/src/lib/eolian_cxx/grammar/klass_def.hpp
@@ -372,6 +372,12 @@ namespace value_ownership
     const bool unmoved = false;
 };
 
+namespace is_by
+{
+    const bool reference = true;
+    const bool value = false;
+};
+
 // type_def represents a type where it is used, like a method parameter or a struc field, in contrast to more
 // specifict types like struct_def, class_def, function_def, which represents a declaration of a type.
 struct type_def
@@ -389,11 +395,11 @@ struct type_def
    type_def(variant_type original_type, std::string c_type, bool has_own, bool is_ptr, bool is_beta, std::string doc_summary)
      : original_type(original_type), c_type(c_type), has_own(has_own), is_ptr(is_ptr), is_beta(is_beta), doc_summary(doc_summary) {}
 
-   type_def(Eolian_Type const* eolian_type, Eolian_Unit const* unit, Eolian_C_Type_Type ctype, bool is_moved)
+   type_def(Eolian_Type const* eolian_type, Eolian_Unit const* unit, std::string const& ctype, bool is_moved, bool is_reference)
    {
-     set(eolian_type, unit, ctype, is_moved);
+     set(eolian_type, unit, ctype, is_moved, is_reference);
    }
-   void set(Eolian_Type const* eolian_type, Eolian_Unit const* unit, Eolian_C_Type_Type ctype, bool is_moved);
+   void set(Eolian_Type const* eolian_type, Eolian_Unit const* unit, std::string const & ctype, bool is_moved, bool is_reference);
    void set(Eolian_Expression_Type eolian_exp_type);
 
    friend inline bool operator<(type_def const& lhs, type_def const& rhs)
@@ -433,14 +439,15 @@ inline bool operator!=(type_def const& lhs, type_def const& rhs)
 
 type_def const void_ {attributes::regular_type_def{"void", {qualifier_info::is_none, {}}, {}}, "void", false, false, false, ""};
 
-inline void type_def::set(Eolian_Type const* eolian_type, Eolian_Unit const* unit, Eolian_C_Type_Type ctype, bool is_moved)
+inline void type_def::set(Eolian_Type const* eolian_type, Eolian_Unit const* unit, std::string const& ctype, bool is_moved, bool is_reference)
 {
-   c_type = ::eolian_type_c_type_get(eolian_type, ctype);
+   c_type = ctype;
    is_value_type = ('*' != c_type.back());
    // ::eina_stringshare_del(stringshare); // this crashes
    Eolian_Type const* stp = eolian_type_base_type_get(eolian_type);
    has_own = is_moved;
-   is_ptr = !!::eolian_type_is_ptr(eolian_type);
+
+   is_ptr = is_reference || eolian_type_is_ptr(eolian_type);
 
    Eolian_Typedecl const* decl = eolian_type_typedecl_get(eolian_type);
    is_beta = decl && eolian_object_is_beta(EOLIAN_OBJECT(decl));
@@ -452,7 +459,7 @@ inline void type_def::set(Eolian_Type const* eolian_type, Eolian_Unit const* uni
    switch( ::eolian_type_type_get(eolian_type))
      {
      case EOLIAN_TYPE_VOID:
-       original_type = attributes::regular_type_def{"void", {qualifiers(eolian_type, is_moved), {}}, {}};
+       original_type = attributes::regular_type_def{"void", {qualifiers(eolian_type, is_moved, is_ptr), {}}, {}};
        break;
      case EOLIAN_TYPE_REGULAR:
        if (!stp)
@@ -474,15 +481,19 @@ inline void type_def::set(Eolian_Type const* eolian_type, Eolian_Unit const* uni
            for(efl::eina::iterator<const char> namespace_iterator( ::eolian_type_namespaces_get(eolian_type))
                  , namespace_last; namespace_iterator != namespace_last; ++namespace_iterator)
              namespaces.push_back(&*namespace_iterator);
-           original_type = {regular_type_def{ ::eolian_type_short_name_get(eolian_type), {qualifiers(eolian_type, is_moved), {}}, namespaces, type_type, is_undefined}};
+           original_type = {regular_type_def{ ::eolian_type_short_name_get(eolian_type), {qualifiers(eolian_type, is_moved, is_ptr), {}}, namespaces, type_type, is_undefined}};
          }
        else
          {
            complex_type_def complex
-            {{::eolian_type_short_name_get(eolian_type), {qualifiers(eolian_type, is_moved), {}}, {}}, {}};
+            {{::eolian_type_short_name_get(eolian_type), {qualifiers(eolian_type, is_moved, is_ptr), {}}, {}}, {}};
            while (stp)
              {
-                complex.subtypes.push_back({stp, unit, EOLIAN_C_TYPE_DEFAULT, eolian_type_is_move(stp)});
+                complex.subtypes.push_back({stp
+                                            , unit
+                                            , ::eolian_type_c_type_get(stp, EOLIAN_C_TYPE_DEFAULT)
+                                            , eolian_type_is_move(stp)
+                                            , is_by::value});
                 stp = eolian_type_next_type_get(stp);
              }
            original_type = complex;
@@ -491,7 +502,7 @@ inline void type_def::set(Eolian_Type const* eolian_type, Eolian_Unit const* uni
      case EOLIAN_TYPE_CLASS:
        {
           Eolian_Class const* klass = eolian_type_class_get(eolian_type);
-          original_type = klass_name(klass, {qualifiers(eolian_type, is_moved), {}});
+          original_type = klass_name(klass, {qualifiers(eolian_type, is_moved, is_ptr), {}});
        }
        break;
      default:
@@ -540,7 +551,12 @@ struct alias_def
        is_undefined = true;
      else
        {
-          base_type = type_def(::eolian_typedecl_base_type_get(alias_obj), unit, EOLIAN_C_TYPE_DEFAULT, value_ownership::unmoved);
+          auto eolian_type = ::eolian_typedecl_base_type_get(alias_obj);
+          base_type = type_def(eolian_type
+                               , unit
+                               , ::eolian_type_c_type_get(eolian_type, EOLIAN_C_TYPE_DEFAULT)
+                               , value_ownership::unmoved
+                               , is_by::value);
           is_undefined = false;
        }
 
@@ -593,7 +609,11 @@ struct parameter_def
                 documentation_def documentation, Eolian_Unit const* unit)
     : direction(std::move(direction)), type(std::move(type)), param_name(std::move(param_name)), documentation(documentation), unit(unit) {}
   parameter_def(Eolian_Function_Parameter const* param, Eolian_Unit const* unit)
-    : type( ::eolian_parameter_type_get(param), unit, EOLIAN_C_TYPE_PARAM, eolian_parameter_is_move(param))
+    : type( ::eolian_parameter_type_get(param)
+            , unit
+            , eolian_parameter_c_type_get(param, EINA_FALSE)
+            , eolian_parameter_is_move(param)
+            , eolian_parameter_is_by_ref(param))
     , param_name( ::eolian_parameter_name_get(param)), unit(unit)
   {
      Eolian_Parameter_Dir direction = ::eolian_parameter_direction_get(param);
@@ -747,7 +767,11 @@ struct function_def
     return_documentation = eolian_function_return_documentation_get(function, type);
     scope = static_cast<member_scope>(eolian_function_scope_get(function, type));
     if(r_type)
-      return_type.set(r_type, unit, EOLIAN_C_TYPE_RETURN, eolian_function_return_is_move(function, type));
+      return_type.set(r_type
+                      , unit
+                      , eolian_function_return_c_type_get(function, type)
+                      , eolian_function_return_is_move(function, type)
+                      , eolian_function_return_is_by_ref(function, type));
      if(type == EOLIAN_METHOD || type == EOLIAN_FUNCTION_POINTER)
        {
           for(efl::eina::iterator<Eolian_Function_Parameter> param_iterator ( ::eolian_function_parameters_get(function))
@@ -1003,7 +1027,11 @@ struct variable_def
   variable_def(Eolian_Variable const* variable, Eolian_Unit const* unit)
         : name(::eolian_variable_short_name_get(variable))
         , full_name(::eolian_variable_name_get(variable))
-        , base_type(::eolian_variable_base_type_get(variable), unit, ::EOLIAN_C_TYPE_DEFAULT, value_ownership::unmoved)
+        , base_type(::eolian_variable_base_type_get(variable)
+                    , unit
+                    , ::eolian_type_c_type_get(eolian_variable_base_type_get(variable), ::EOLIAN_C_TYPE_DEFAULT)
+                    , value_ownership::unmoved
+                    , is_by::value)
         , documentation(::eolian_variable_documentation_get(variable))
         , type(static_cast<variable_type>(::eolian_variable_type_get(variable)))
         , expression_value()
@@ -1087,7 +1115,12 @@ struct event_def
 
   event_def(Eolian_Event const* event, Eolian_Class const* cls, Eolian_Unit const* unit)
     : klass(cls, {attributes::qualifier_info::is_none, std::string()})
-    , type( ::eolian_event_type_get(event) ? eina::optional<type_def>{{::eolian_event_type_get(event), unit, EOLIAN_C_TYPE_DEFAULT, value_ownership::unmoved}} : eina::optional<type_def>{})
+    , type( ::eolian_event_type_get(event) ? eina::optional<type_def>{{::eolian_event_type_get(event)
+                                                                       , unit
+                                                                       , ::eolian_type_c_type_get(::eolian_event_type_get(event), EOLIAN_C_TYPE_DEFAULT)
+                                                                       , value_ownership::unmoved
+                                                                       , is_by::value}
+             } : eina::optional<type_def>{})
     , name( ::eolian_event_name_get(event))
     , c_name( ::eolian_event_c_macro_get(event))
     , beta( ::eolian_event_is_beta(event))
@@ -1552,8 +1585,11 @@ struct struct_field_def
   {
      name = eolian_typedecl_struct_field_name_get(struct_field);
      try {
-        type.set(eolian_typedecl_struct_field_type_get(struct_field), unit, EOLIAN_C_TYPE_DEFAULT
-                , eolian_typedecl_struct_field_is_move(struct_field));
+        type.set(eolian_typedecl_struct_field_type_get(struct_field)
+                , unit
+                , eolian_typedecl_struct_field_c_type_get(struct_field)
+                , eolian_typedecl_struct_field_is_move(struct_field)
+                , eolian_typedecl_struct_field_is_by_ref(struct_field));
      } catch(std::runtime_error const&) { /* Silently skip pointer fields*/ }
      documentation = ::eolian_typedecl_struct_field_documentation_get(struct_field);
   }
diff --git a/src/lib/eolian_cxx/grammar/qualifier_def.hpp b/src/lib/eolian_cxx/grammar/qualifier_def.hpp
index cab3ca8667..0823010437 100644
--- a/src/lib/eolian_cxx/grammar/qualifier_def.hpp
+++ b/src/lib/eolian_cxx/grammar/qualifier_def.hpp
@@ -72,11 +72,11 @@ inline qualifier_bool operator^(qualifier_bool lhs, qualifier_info rhs)
   return lhs;
 }
 
-inline qualifier_info qualifiers(Eolian_Type const* type, bool is_moved)
+inline qualifier_info qualifiers(Eolian_Type const* type, bool is_moved, bool is_by_ref)
 {
   qualifier_info is_own = is_moved ? qualifier_info::is_own : qualifier_info::is_none;
   qualifier_info is_const = ::eolian_type_is_const(type) ? qualifier_info::is_const : qualifier_info::is_none;
-  qualifier_info is_ref = ::eolian_type_is_ptr(type) ? qualifier_info::is_ref : qualifier_info::is_none;
+  qualifier_info is_ref = is_by_ref ? qualifier_info::is_ref : qualifier_info::is_none;
   return is_own | is_const | is_ref;
 }