cxx: Fix compilation after merge

This resolves a few issues and brings back the experimental features.

Also, disable some of the ugliest experiments:
 - manual function overrides,
 - define APIs only in eo_cxx namespace

Some APIs are generated behind EFL_CXXPERIMENT (eg. event_name_cb_add or
some weak pointer stuff). I believe they are useful but would like to
make sure there are no serious drawbacks with generating those.

10 files changed, 49 insertions, 28 deletions

diff --git a/src/lib/eolian_cxx/grammar/class_definition.hpp b/src/lib/eolian_cxx/grammar/class_definition.hpp
index 771121d8ee..b282f71bf9 100644
--- a/src/lib/eolian_cxx/grammar/class_definition.hpp
+++ b/src/lib/eolian_cxx/grammar/class_definition.hpp
@@ -208,26 +208,17 @@ struct class_definition_generator
      if(!as_generator(scope_tab << "/// @endcond\n").generate(sink, attributes::unused, context)) return false;
 
      // EXPERIMENTAL: Parts
-     if(!as_generator("#ifdef EFL_CXXPERIMENTAL\n").generate(sink, attributes::unused, context)) return false;
-     if(!as_generator(*(scope_tab << part_declaration << ";\n"))
-           .generate(sink, cls.parts, context)) return false;
-     if(!as_generator("#endif \n").generate(sink, attributes::unused, context)) return false;
+     if (!cls.parts.empty())
+       {
+          if(!as_generator("#ifdef EFL_CXXPERIMENTAL\n").generate(sink, attributes::unused, context)) return false;
+          if(!as_generator(*(scope_tab << part_declaration << ";\n"))
+                .generate(sink, cls.parts, context)) return false;
+          if(!as_generator("#endif \n").generate(sink, attributes::unused, context)) return false;
+       }
 
      if(!as_generator(   scope_tab << "::efl::eo::wref<" << string << "> _get_wref() const { "
                          "return ::efl::eo::wref<" << string << ">(*this); }\n"
-                     ).generate(sink, std::make_tuple(cls.cxx_name, cls.cxx_name), context)) return false;
-
-     // EXPERIMENTAL: wref and implicit conversion to Eo*
-     if(!as_generator("#ifdef EFL_CXXPERIMENTAL\n").generate(sink, attributes::unused, context)) return false;
-     // For easy wref, operator-> in wref needs to also return a pointer type
-     if(!as_generator(   scope_tab << "const " << string << "* operator->() const { return this; }\n"
-                     ).generate(sink, std::make_tuple(cls.cxx_name, cls.cxx_name), context)) return false;
-     if(!as_generator(   scope_tab << string << "* operator->() { return this; }\n"
-                     ).generate(sink, std::make_tuple(cls.cxx_name, cls.cxx_name), context)) return false;
-     // For easy interfacing with C: no need to use _eo_ptr()
-     if(!as_generator(   scope_tab << "operator Eo*() const { return _eo_ptr(); }\n"
-                     ).generate(sink, attributes::unused, context)) return false;
-     if(!as_generator("#endif \n").generate(sink, attributes::unused, context)) return false;
+                         ).generate(sink, std::make_tuple(cls.cxx_name, cls.cxx_name), context)) return false;
 
      // eo_concrete
      if(!as_generator(   scope_tab << "::efl::eo::concrete const& _get_concrete() const { return *this; }\n"
@@ -241,6 +232,18 @@ struct class_definition_generator
                       << scope_tab << "using ::efl::eo::concrete::operator bool;\n"
                       ).generate(sink, attributes::unused, context)) return false;
 
+     // EXPERIMENTAL: wref and implicit conversion to Eo*
+     if(!as_generator("#ifdef EFL_CXXPERIMENTAL\n").generate(sink, attributes::unused, context)) return false;
+     // For easy wref, operator-> in wref needs to also return a pointer type
+     if(!as_generator(   scope_tab << "const " << string << "* operator->() const { return this; }\n"
+                     ).generate(sink, std::make_tuple(cls.cxx_name, cls.cxx_name), context)) return false;
+     if(!as_generator(   scope_tab << string << "* operator->() { return this; }\n"
+                     ).generate(sink, std::make_tuple(cls.cxx_name, cls.cxx_name), context)) return false;
+     // For easy interfacing with C: no need to use _eo_ptr()
+     if(!as_generator(   scope_tab << "operator Eo*() const { return _eo_ptr(); }\n"
+                     ).generate(sink, attributes::unused, context)) return false;
+     if(!as_generator("#endif \n").generate(sink, attributes::unused, context)) return false;
+
      if(!as_generator(   scope_tab << "friend bool operator==(" << string << " const& lhs, " << string << " const& rhs)\n"
                       << scope_tab << "{ return lhs._get_concrete() == rhs._get_concrete(); }\n"
                       << scope_tab << "friend bool operator!=(" << string << " const& lhs, " << string << " const& rhs)\n"
diff --git a/src/lib/eolian_cxx/grammar/context.hpp b/src/lib/eolian_cxx/grammar/context.hpp
index 79e54178e0..e4839200bc 100644
--- a/src/lib/eolian_cxx/grammar/context.hpp
+++ b/src/lib/eolian_cxx/grammar/context.hpp
@@ -56,7 +56,7 @@ Tag const& context_find_tag(context_cons<OtherTag, Tail> const& context
 }
 
 template <typename Tag, typename OtherTag, typename Tail> 
-Tag const& context_find_tag(context_null const& context)
+Tag const& context_find_tag(context_null const&)
 {
   throw std::logic_error("Context for generation not available");
 }
diff --git a/src/lib/eolian_cxx/grammar/function_declaration.hpp b/src/lib/eolian_cxx/grammar/function_declaration.hpp
index a2770abf18..f30f7569dc 100644
--- a/src/lib/eolian_cxx/grammar/function_declaration.hpp
+++ b/src/lib/eolian_cxx/grammar/function_declaration.hpp
@@ -48,10 +48,12 @@ struct function_declaration_generator
             .generate(sink, std::make_tuple(_klass_name.namespaces, _klass_name.eolian_name), add_upper_case_context(ctx)))
         return false;
 
+#ifdef USE_EOCXX_MANUAL_OVERRIDES
       if(!as_generator
             ("#ifndef EOLIAN_CXX_" << string << "_DECLARATION\n")
             .generate(sink, f.c_name, add_upper_case_context(ctx)))
         return false;
+#endif
 
       std::string template_statement(f.template_statement());
       if (!template_statement.empty() &&
@@ -68,11 +70,13 @@ struct function_declaration_generator
             .generate(sink, std::make_tuple(f.return_type, escape_keyword(f.name), f.parameters), ctx))
         return false;
 
+#ifdef USE_EOCXX_MANUAL_OVERRIDES
       if(!as_generator
             ("#else\n" << scope_tab << "EOLIAN_CXX_" << string << "_DECLARATION\n"
              "#endif\n")
             .generate(sink, f.c_name, add_upper_case_context(ctx)))
         return false;
+#endif
 
       if(f.is_protected &&
             !as_generator("#endif\n").generate(sink, attributes::unused, ctx))
diff --git a/src/lib/eolian_cxx/grammar/function_definition.hpp b/src/lib/eolian_cxx/grammar/function_definition.hpp
index 46df876b33..3161b76041 100644
--- a/src/lib/eolian_cxx/grammar/function_definition.hpp
+++ b/src/lib/eolian_cxx/grammar/function_definition.hpp
@@ -54,10 +54,12 @@ struct function_definition_generator
          .generate(sink, std::make_tuple(_klass_name.namespaces, _klass_name.eolian_name), add_upper_case_context(ctx)))
         return false;
 
+#ifdef USE_EOCXX_MANUAL_OVERRIDES
       if(!as_generator
             ("#ifndef EOLIAN_CXX_" << string << "_IMPLEMENTATION\n")
             .generate(sink, f.c_name, add_upper_case_context(ctx)))
         return false;
+#endif
 
       std::string template_statement(f.template_statement());
       if (!template_statement.empty() &&
@@ -166,11 +168,13 @@ struct function_definition_generator
       if(!as_generator("}\n").generate(sink, attributes::unused, ctx))
         return false;
 
+#ifdef USE_EOCXX_MANUAL_OVERRIDES
       if(!as_generator
             ("#else\n" << scope_tab << "EOLIAN_CXX_" << string << "_IMPLEMENTATION\n"
              "#endif\n")
             .generate(sink, f.c_name, add_upper_case_context(ctx)))
         return false;
+#endif
 
       if(f.is_beta &&
          !as_generator("#endif\n").generate(sink, attributes::unused, ctx))
diff --git a/src/lib/eolian_cxx/grammar/generator.hpp b/src/lib/eolian_cxx/grammar/generator.hpp
index 10e96c7c13..6d0be7e4f1 100644
--- a/src/lib/eolian_cxx/grammar/generator.hpp
+++ b/src/lib/eolian_cxx/grammar/generator.hpp
@@ -5,6 +5,7 @@
 
 // EXPERIMENTAL
 //#define USE_EOCXX_INHERIT_ONLY
+//#define USE_EOCXX_MANUAL_OVERRIDES
 
 namespace efl { namespace eolian { namespace grammar {
 
diff --git a/src/lib/eolian_cxx/grammar/klass_def.hpp b/src/lib/eolian_cxx/grammar/klass_def.hpp
index b2aae1bbef..1cb5ecfba0 100644
--- a/src/lib/eolian_cxx/grammar/klass_def.hpp
+++ b/src/lib/eolian_cxx/grammar/klass_def.hpp
@@ -458,17 +458,15 @@ struct function_def
     return !(lhs == rhs);
   }
   function_def() = default;
-  function_def(type_def return_type, std::string name, std::vector<parameter_def> parameters
-               , std::string c_name, std::string filename, bool is_beta)
-    : return_type(return_type), name(name), parameters(parameters), c_name(c_name), filename(filename), is_beta(is_beta) {}
   function_def(type_def _return_type, std::string const& _name,
                std::vector<parameter_def> const& _parameters,
                std::string const& _c_name,
+               std::string _filename,
                bool _is_beta = false,
                bool _is_protected = false,
                bool _is_function_pointer = false)
     : return_type(_return_type), name(_name), parameters(_parameters),
-      c_name(_c_name), is_beta(_is_beta), is_protected(_is_protected),
+      c_name(_c_name), filename(_filename), is_beta(_is_beta), is_protected(_is_protected),
       is_function_pointer(_is_function_pointer) {}
 
   function_def( ::Eolian_Function const* function, Eolian_Function_Type type, Eolian_Unit const* unit)
@@ -572,7 +570,7 @@ struct function_def
                char typenam[2] = { 0, };
                typenam[0] = template_typename++;
                std::string statement = "auto fw = new ::efl::eolian::function_wrapper<";
-               statement += param.c_type + ", " + typenam + ">(" + param.param_name + ");";
+               statement += param.type.c_type + ", " + typenam + ">(" + param.param_name + ");";
                statements.push_back(statement);
             }
        }
diff --git a/src/lib/eolian_cxx/grammar/parameter.hpp b/src/lib/eolian_cxx/grammar/parameter.hpp
index 5d8d3aef5c..68f5450dd1 100644
--- a/src/lib/eolian_cxx/grammar/parameter.hpp
+++ b/src/lib/eolian_cxx/grammar/parameter.hpp
@@ -78,12 +78,20 @@ struct parameter_as_argument_generator
    template <typename OutputIterator, typename Context>
    bool generate(OutputIterator sink, attributes::parameter_def const& param, Context const& context) const
    {
-      return as_generator(parameter_type << "(" << string << ")").generate(sink, std::make_tuple(param, param.param_name), context);
+      attributes::parameter_def param_copy = param;
+      if (param.direction == attributes::parameter_direction::in)
+        param_copy.direction = attributes::parameter_direction::out;
+      else if (param.direction == attributes::parameter_direction::out)
+        param_copy.direction = attributes::parameter_direction::in;
+      return as_generator(parameter_type << "(" << string << ")")
+            .generate(sink, std::make_tuple(param_copy, param_copy.param_name), context);
    }
 };
 
 template <>
 struct is_eager_generator<parameter_as_argument_generator> : std::true_type {};
+template <>
+struct is_generator<parameter_as_argument_generator> : std::true_type {};
 namespace type_traits {
 template <>
 struct attributes_needed<parameter_as_argument_generator> : std::integral_constant<int, 1> {};
diff --git a/src/lib/eolian_cxx/grammar/part_declaration.hpp b/src/lib/eolian_cxx/grammar/part_declaration.hpp
index 04258c4020..30646fcbae 100644
--- a/src/lib/eolian_cxx/grammar/part_declaration.hpp
+++ b/src/lib/eolian_cxx/grammar/part_declaration.hpp
@@ -31,7 +31,8 @@ struct part_declaration_generator
 
 template <>
 struct is_eager_generator<part_declaration_generator> : std::true_type {};
-
+template <>
+struct is_generator<part_declaration_generator> : std::true_type {};
 namespace type_traits {
 template <>
 struct attributes_needed<part_declaration_generator> : std::integral_constant<int, 1> {};
diff --git a/src/lib/eolian_cxx/grammar/part_implementation.hpp b/src/lib/eolian_cxx/grammar/part_implementation.hpp
index cee2fc7fa8..692ebca7c1 100644
--- a/src/lib/eolian_cxx/grammar/part_implementation.hpp
+++ b/src/lib/eolian_cxx/grammar/part_implementation.hpp
@@ -53,7 +53,8 @@ private:
 
 template <>
 struct is_eager_generator<part_implementation_generator> : std::true_type {};
-
+template <>
+struct is_generator<part_implementation_generator> : std::true_type {};
 namespace type_traits {
 template <>
 struct attributes_needed<part_implementation_generator> : std::integral_constant<int, 1> {};
diff --git a/src/lib/eolian_cxx/grammar/type_function_declaration.hpp b/src/lib/eolian_cxx/grammar/type_function_declaration.hpp
index eccedf8f4a..93ebe45940 100644
--- a/src/lib/eolian_cxx/grammar/type_function_declaration.hpp
+++ b/src/lib/eolian_cxx/grammar/type_function_declaration.hpp
@@ -56,7 +56,7 @@ struct type_function_declaration_generator {
 
       std::vector<std::string> c_args;
       for (auto itr : f.parameters)
-        c_args.push_back(", " + itr.c_type + " " + itr.param_name);
+        c_args.push_back(", " + itr.type.c_type + " " + itr.param_name);
       if (!as_generator(
              scope_tab << "static " << string << " caller(void *cxx_call_data"
              << *(string) << ") {\n"
@@ -102,7 +102,8 @@ struct type_function_declaration_generator {
 
 template <>
 struct is_eager_generator<type_function_declaration_generator> : std::true_type {};
-
+template <>
+struct is_generator<type_function_declaration_generator> : std::true_type {};
 namespace type_traits {
 template <>
 struct attributes_needed<type_function_declaration_generator> : std::integral_constant<int, 1> {};