Cast explicitily in unpack call to avoid confilt with Optional. (#5380)

Co-authored-by: Bowen Chen <bob2420083992@gmail.com>
Co-authored-by: oneflow-ci-bot <69100618+oneflow-ci-bot@users.noreply.github.com>

oneflow/api/python/functional/py_function.h

@@ -48,7 +48,7 @@ inline py::object PyFunction(py::args args, py::kwargs kwargs) {
   }
   using FType = typename SchemaT::FType;
   using R = typename SchemaT::R;
-  return py::cast(detail::unpack_call<FType, R, PythonArg>::apply(*SchemaT::func, _args));
+  return py::cast(detail::unpack_call<FType, R>::apply(*SchemaT::func, _args));
 }
 
 }  // namespace functional

oneflow/api/python/functional/python_arg.h

@@ -77,7 +77,7 @@ class PythonArg {
   };
 
   template<typename T>
-  operator T() const {
+  T As() const {
     if (active_tag_ == HAS_IMMEDIATE) {
       CHECK_EQ_OR_THROW(ValueTypeOf<T>(), immediate_->value_type())
           << "Could not convert immediate value from type " << immediate_->value_type()

oneflow/api/python/functional/unpack_call.h

@@ -17,6 +17,8 @@ limitations under the License.
 #define ONEFLOW_API_PYTHON_FUNCTIONAL_UNPACK_CALL_H_
 
 #include "oneflow/api/python/functional/python_arg.h"
+
+#include <tuple>
 #include "oneflow/core/framework/tensor.h"
 #include "oneflow/core/framework/tensor_tuple.h"
 #include "oneflow/core/common/function_traits.h"
@@ -27,41 +29,43 @@ namespace functional {
 
 namespace detail {
 
-template<typename F, typename R, typename T, int nleft, int index>
+template<typename F, typename R, int nleft, int index>
 struct unpack_call_dispatcher {
   template<typename... Args>
-  static R apply(const F& f, const std::vector<T>& args, Args&&... unpacked_args) {
-    return unpack_call_dispatcher<F, R, T, nleft - 1, index + 1>::apply(
-        f, args, std::forward<Args>(unpacked_args)..., args[index]);
+  static R apply(const F& f, const std::vector<PythonArg>& args, Args&&... unpacked_args) {
+    using type = typename std::tuple_element<index, typename function_traits<F>::args_type>::type;
+    return unpack_call_dispatcher<F, R, nleft - 1, index + 1>::apply(
+        f, args, std::forward<Args>(unpacked_args)...,
+        args[index].As<oneflow::detail::remove_cvref_t<type>>());
   }
 };
 
-template<typename F, typename R, typename T, int index>
-struct unpack_call_dispatcher<F, R, T, 0, index> {
+template<typename F, typename R, int index>
+struct unpack_call_dispatcher<F, R, 0, index> {
   template<typename... Args>
-  static R apply(const F& f, const std::vector<T>& args, Args&&... unpacked_args) {
+  static R apply(const F& f, const std::vector<PythonArg>& args, Args&&... unpacked_args) {
     return f(std::forward<Args>(unpacked_args)...);
   }
 };
 
-template<typename F, typename R, typename T>
+template<typename F, typename R>
 struct unpack_call {
-  static R apply(const F& f, const std::vector<T>& args) {
+  static R apply(const F& f, const std::vector<PythonArg>& args) {
     constexpr size_t nargs = function_traits<F>::nargs;
     CHECK_EQ(nargs, args.size()) << "Requires " << nargs << " arguments, but " << args.size()
                                  << " is given.";
-    return unpack_call_dispatcher<F, R, T, nargs, 0>::apply(f, args);
+    return unpack_call_dispatcher<F, R, nargs, 0>::apply(f, args);
   }
 };
 
 #define INSTANCE_MAYBE_UNPACK_CALL(K, R, return_fn)                                     \
-  template<typename F, typename T>                                                      \
-  struct unpack_call<F, K, T> {                                                         \
-    static R apply(const F& f, const std::vector<T>& args) {                            \
+  template<typename F>                                                                  \
+  struct unpack_call<F, K> {                                                            \
+    static R apply(const F& f, const std::vector<PythonArg>& args) {                    \
       constexpr size_t nargs = function_traits<F>::nargs;                               \
       CHECK_EQ(nargs, args.size())                                                      \
           << "Requires " << nargs << " arguments, but " << args.size() << " is given."; \
-      return (return_fn)(unpack_call_dispatcher<F, K, T, nargs, 0>::apply(f, args));    \
+      return (return_fn)(unpack_call_dispatcher<F, K, nargs, 0>::apply(f, args));       \
     }                                                                                   \
   };