rice 4.7.0 → 4.8.0

data/rice/detail/Native.hpp

@@ -11,8 +11,7 @@ namespace Rice::detail
     inline bool operator<(Resolved other);
     inline bool operator>(Resolved other);
 
-    Convertible convertible;
-    double parameterMatch;
+    double score;  // Combined score: minParameterScore * parameterMatch
     Native* native;
   };
 
@@ -23,7 +22,8 @@ namespace Rice::detail
     Iterator,
     AttributeReader,
     AttributeWriter,
-    Proc
+    Proc,
+    Callback
   };
 
   class Native
@@ -31,8 +31,9 @@ namespace Rice::detail
   public:
     static VALUE resolve(int argc, VALUE* argv, VALUE self);
   public:
-    Native() = default;
-    Native(std::vector<std::unique_ptr<ParameterAbstract>>&& parameters);
+    Native(std::string name);
+    Native(std::string name, std::unique_ptr<Return>&& returnInfo);
+    Native(std::string name, std::unique_ptr<Return>&& returnInfo, std::vector<std::unique_ptr<ParameterAbstract>>&& parameters);
     virtual ~Native() = default;
 
     Native(const Native&) = delete;
@@ -40,36 +41,45 @@ namespace Rice::detail
     void operator=(const Native&) = delete;
     void operator=(Native&&) = delete;
 
-    virtual Resolved matches(size_t argc, const VALUE* argv, VALUE self);
-    virtual VALUE operator()(size_t argc, const VALUE* argv, VALUE self) = 0;
+    virtual Resolved matches(std::map<std::string, VALUE>& values);
+    virtual VALUE operator()(std::map<std::string, VALUE>& values, VALUE self) = 0;
     virtual std::string toString() = 0;
 
     // Ruby API access
-    virtual std::string name() = 0;
+    std::string name();
+    std::vector<const ParameterAbstract*> parameters();
     virtual NativeKind kind() = 0;
     virtual VALUE returnKlass() = 0;
-    std::vector<const ParameterAbstract*> parameters();
 
   protected:
-    template<typename T>
-    static void verify_type(bool isBuffer);
+    template<typename T, bool isBuffer>
+    static void verify_type();
 
-    template<typename Tuple_T, std::size_t ...Indices>
-    static void verify_args(MethodInfo* methodInfo, std::index_sequence<Indices...> indices);
-
-    std::vector<std::optional<VALUE>> getRubyValues(size_t argc, const VALUE* argv, bool validate);
+    static std::map<std::string, VALUE> readRubyArgs(size_t argc, const VALUE* argv);
+    std::vector<std::optional<VALUE>> getRubyValues(std::map<std::string, VALUE> values, bool validate);
     ParameterAbstract* getParameterByName(std::string name);
-    Convertible matchParameters(std::vector<std::optional<VALUE>>& values);
+    double matchParameters(std::vector<std::optional<VALUE>>& values, size_t argc);
+
+    template<typename Parameter_Tuple, typename... Arg_Ts>
+    static std::vector<std::unique_ptr<ParameterAbstract>> create_parameters(Arg_Ts&& ...args);
 
-    template<typename Tuple_T>
-    static std::vector<std::unique_ptr<ParameterAbstract>> create_parameters(MethodInfo* methodInfo);
+    template<typename... Arg_Ts>
+    static std::unique_ptr<Return> create_return(Arg_Ts& ...args);
 
-    template<typename Tuple_T, std::size_t ...Indices>
-    static inline void create_parameters_impl(std::vector<std::unique_ptr<ParameterAbstract>>& parameters, MethodInfo* methodInfo, std::index_sequence<Indices...> indices);
+    // Do we need to keep alive any arguments?
+    void checkKeepAlive(VALUE self, VALUE returnValue, std::vector<std::optional<VALUE>>& rubyValues);
+
+  private:
+    template<typename Parameter_Tuple, typename Arg_Tuple, std::size_t ...Indices>
+    static inline void create_parameters_impl(std::vector<std::unique_ptr<ParameterAbstract>>& parameters, std::index_sequence<Indices...> indices, std::vector<std::unique_ptr<Arg>>&& args);
+
+    template<typename Parameter_Tuple, typename Arg_Tuple, size_t I>
+    static void verify_parameter();
 
   protected:
+    std::string name_;
+    std::unique_ptr<Return> returnInfo_;
     std::vector<std::unique_ptr<ParameterAbstract>> parameters_;
-
   };
 }
 

data/rice/detail/Native.ipp

@@ -1,58 +1,41 @@
-
 namespace Rice::detail
 {
   inline bool Resolved::operator<(Resolved other)
   {
-    if (this->convertible != other.convertible)
-    {
-      return this->convertible < other.convertible;
-    }
-    else
-    {
-      return this->parameterMatch < other.parameterMatch;
-    }
+    return this->score < other.score;
   }
 
   inline bool Resolved::operator>(Resolved other)
   {
-    if (this->convertible != other.convertible)
-    {
-      return this->convertible > other.convertible;
-    }
-    else
-    {
-      return this->parameterMatch > other.parameterMatch;
-    }
+    return this->score > other.score;
   }
 
   inline VALUE Native::resolve(int argc, VALUE* argv, VALUE self)
   {
     /* This method is called from Ruby and is responsible for determining the correct
-       Native object (ie, NativeFunction, NativeIterator, NativeAttributeGet and 
-       NativeAttributeSet) that shoudl be used to invoke the underlying C++ code.
+       Native object (ie, NativeFunction, NativeIterator, NativeAttributeGet and
+       NativeAttributeSet) that should be used to invoke the underlying C++ code.
        Most of the time there will be a single Native object registered for a C++ function,
-       method, constructor, iterator or attribute. However, there can be multiple Natives 
-       when a C++ function/method/construtor is overloaded.
+       method, constructor, iterator or attribute. However, there can be multiple Natives
+       when a C++ function/method/constructor is overloaded.
 
        In that case, the code iterates over each Native and calls its matches method. The matches
-       method returns a Resolved object which includes a Convertible field and parameterMatch field.
-       The Convertible field is an enum that specifies if the types of the values supplied by Ruby
-       match the types of the C++ function parameters. Allowed values include  can be Exact (example Ruby into to C++ int),
-       TypeCast (example Ruby into to C++ float) or None (cannot be converted). 
+       method returns a Resolved object with a numeric score (0.0 to 1.0). The score is computed as:
+
+         score = minParameterScore * parameterMatch
 
-       The parameterMatch field is simply the number or arguments provided by Ruby divided by the
-       number of arguments required by C++. These numbers can be different because C++ method 
-       parameters can have default values.
+       where minParameterScore is the minimum score across all passed parameters (using precision-based
+       scoring for numeric types), and parameterMatch applies a small penalty (0.99) for each default
+       parameter used. If not enough arguments are provided and missing parameters don't have defaults,
+       the method returns 0 (not viable).
 
-       Taking these two values into account, the method sorts the Natives and picks the one with the 
-       highest score (Convertible::Exact and 1.0 for parameterMatch). Thus given these two C++ functions:
+       The method sorts the Natives and picks the one with the highest score. Given these two C++ functions:
 
        void some_method(int a);
-       void some_mtehod(int a, float b = 2.0).
+       void some_method(int a, float b = 2.0);
 
-       A call from ruby of some_method(1) will exactly match both signatures, but the first one 
-       will be chosen because the parameterMatch will be 1.0 for the first overload but 0.5
-       for the second. */
+       A call from ruby of some_method(1) will match both signatures, but the first one
+       will be chosen because parameterMatch = 1.0 for the first overload but 0.99 for the second. */
 
     Native* native = nullptr;
 
@@ -64,11 +47,9 @@ namespace Rice::detail
     }
 
     // Execute the function but make sure to catch any C++ exceptions!
-    return cpp_protect([&]
+    return cpp_protect([&]()
     {
-      Identifier id(methodId);
-      std::string methodName = id.str();
-      std::string className = rb_class2name(klass);
+      std::map<std::string, VALUE> values = readRubyArgs(argc, argv);
 
       const std::vector<std::unique_ptr<Native>>& natives = Registries::instance.natives.lookup(klass, methodId);
 
@@ -91,7 +72,7 @@ namespace Rice::detail
           std::back_inserter(resolves), 
           [&](const std::unique_ptr<Native>& native)
           {
-            return native->matches(argc, argv, self);
+            return native->matches(values);
           });
 
         // Now sort from best to worst
@@ -122,7 +103,7 @@ namespace Rice::detail
         }*/
 
         // Did it match?
-        if (resolved.convertible != Convertible::None)
+        if (resolved.score > Convertible::None)
         {
           native = resolved.native;
         }
@@ -151,19 +132,34 @@ namespace Rice::detail
       }
 
       // Call the C++ function
-      return (*native)(argc, argv, self);
+      return (*native)(values, self);
     });
   }
 
-  inline Native::Native(std::vector<std::unique_ptr<ParameterAbstract>>&& parameters) : parameters_(std::move(parameters))
+  inline Native::Native(std::string name) :
+    name_(name)
+  {
+  }
+
+  inline Native::Native(std::string name,std::unique_ptr<Return>&& returnInfo) :
+    name_(name), returnInfo_(std::move(returnInfo))
+  {
+  }
+
+  inline Native::Native(std::string name, std::unique_ptr<Return>&& returnInfo, std::vector<std::unique_ptr<ParameterAbstract>>&& parameters) :
+    name_(name), returnInfo_(std::move(returnInfo)), parameters_(std::move(parameters))
   {
   }
 
+  inline std::string Native::name()
+  {
+    return this->name_;
+  }
   inline ParameterAbstract* Native::getParameterByName(std::string name)
   {
     for (std::unique_ptr<ParameterAbstract>& parameter : this->parameters_)
     {
-      if (parameter->arg->name == name)
+      if (parameter->arg()->name == name)
       {
         return parameter.get();
       }
@@ -172,168 +168,320 @@ namespace Rice::detail
     return nullptr;
   }
 
-  // -----------  Helpers ----------------
-  template<typename T>
-  inline void Native::verify_type(bool isBuffer)
+  inline void Native::checkKeepAlive(VALUE self, VALUE returnValue, std::vector<std::optional<VALUE>>& rubyValues)
   {
-    using Base_T = std::remove_pointer_t<remove_cv_recursive_t<T>>;
-
-    detail::verifyType<T>();
-
-    if constexpr (std::is_pointer_v<T> && std::is_fundamental_v<std::remove_pointer_t<T>>)
+    // Check function arguments
+    for (size_t i = 0; i < this->parameters_.size(); i++)
     {
-      Type<Pointer<std::remove_pointer_t<T>>>::verify();
-      Type<Buffer<std::remove_pointer_t<T>>>::verify();
+      Arg* arg = parameters_[i]->arg();
+      if (arg->isKeepAlive())
+      {
+        static WrapperBase* selfWrapper = getWrapper(self);
+        selfWrapper->addKeepAlive(rubyValues[i].value());
+      }
     }
-    if constexpr (std::is_array_v<T>)
+
+    // Check return value
+    if (this->returnInfo_->isKeepAlive())
     {
-      Type<Pointer<std::remove_extent_t<remove_cv_recursive_t<T>>>>::verify();
-      Type<Buffer<std::remove_extent_t<remove_cv_recursive_t<T>>>>::verify();
+      WrapperBase* returnWrapper = getWrapper(returnValue);
+      returnWrapper->addKeepAlive(self);
     }
-    else if (isBuffer)
+  }
+
+  // -----------  Type Checking ----------------
+  template<typename T, bool isBuffer>
+  inline void Native::verify_type()
+  {
+    detail::verifyType<T>();
+
+    if constexpr (std::is_pointer_v<T>)
     {
-      if constexpr (std::is_pointer_v<T> && !std::is_function_v<Base_T> && !std::is_abstract_v<Base_T>)
+      using Base_T = std::remove_pointer_t<remove_cv_recursive_t<T>>;
+
+      if constexpr (std::is_fundamental_v<Base_T> || std::is_pointer_v<Base_T> || isBuffer)
       {
         Type<Pointer<Base_T>>::verify();
-        Type<Buffer<Base_T>>::verify();
       }
-      else
+    }
+    else if constexpr (std::is_reference_v<T>)
+    {
+      using Base_T = std::remove_reference_t<remove_cv_recursive_t<T>>;
+
+      if constexpr (std::is_fundamental_v<Base_T>)
       {
-        static_assert(true, "Only pointer types can be marked as buffers");
+        Type<Reference<Base_T>>::verify();
       }
     }
+    else if constexpr (std::is_array_v<T>)
+    {
+      using Base_T = std::remove_extent_t<remove_cv_recursive_t<T>>;
+
+      Type<Pointer<Base_T>>::verify();
+    }
   }
 
-  template<typename Tuple_T, std::size_t ...Indices>
-  inline void Native::verify_args(MethodInfo* methodInfo, std::index_sequence<Indices...> indices)
+  template<typename Parameter_Tuple, typename Arg_Tuple, size_t I>
+  inline void Native::verify_parameter()
   {
-    (Native::verify_type<std::tuple_element_t<Indices, Tuple_T>>(methodInfo->arg(Indices)->isBuffer()), ...);
-  }
+    using Param_T = std::tuple_element_t<I, Parameter_Tuple>;
+    using Arg_T = std::tuple_element_t<I, Arg_Tuple>;
+    if constexpr (std::is_same_v<ArgBuffer, std::decay_t<Arg_T>>)
+    {
+      verify_type<Param_T, true>();
+    }
+    else
+    {
+      verify_type<Param_T, false>();
+    }
+  };
 
-  template<typename Tuple_T, std::size_t ...Indices>
-  inline void Native::create_parameters_impl(std::vector<std::unique_ptr<ParameterAbstract>>& parameters, MethodInfo* methodInfo, std::index_sequence<Indices...> indices)
+  template<typename Parameter_Tuple, typename Arg_Tuple, std::size_t ...Indices>
+  inline void Native::create_parameters_impl(std::vector<std::unique_ptr<ParameterAbstract>>& parameters, std::index_sequence<Indices...>, std::vector<std::unique_ptr<Arg>>&& args)
   {
-    (parameters.push_back(std::move(std::make_unique<Parameter<std::tuple_element_t<Indices, Tuple_T>>>(methodInfo->arg(Indices)))), ...);
+    // Verify parameter types
+    (verify_parameter<Parameter_Tuple, Arg_Tuple, Indices>(), ...);
+
+    // Create parameters
+    (parameters.push_back(std::move(std::make_unique<
+      Parameter<std::tuple_element_t<Indices, Parameter_Tuple>>>(std::move(args[Indices])))), ...);
   }
 
-  template<typename Tuple_T>
-  inline std::vector<std::unique_ptr<ParameterAbstract>> Native::create_parameters(MethodInfo* methodInfo)
+  template<typename Parameter_Tuple, typename... Arg_Ts>
+  inline std::vector<std::unique_ptr<ParameterAbstract>> Native::create_parameters(Arg_Ts&& ...args)
   {
     std::vector<std::unique_ptr<ParameterAbstract>> result;
-    auto indices = std::make_index_sequence<std::tuple_size_v<Tuple_T>>{};
-    Native::create_parameters_impl<Tuple_T>(result, methodInfo, indices);
+
+    // Extract Arg and ArgBuffer from Arg_Ts and then pad Arg to match the size of Parameter_Tuple
+    using ArgsBaseTuple = tuple_filter_types_t<std::tuple<Arg_Ts...>, Arg, ArgBuffer>;
+
+    // Diff can be less than zero so it has to be signed! This happens when define_method is called with a self
+    // parameter and specifies one or more Args (usually to call Arg("self).setValue()). 
+    // In that case the self parameter is considered Class_T and there are no arguments.
+    constexpr long diff = (long)std::tuple_size_v<Parameter_Tuple> - (long)std::tuple_size_v<ArgsBaseTuple>;
+    using ArgsTuple = tuple_pad_type_t<ArgsBaseTuple, Arg, diff < 0 ? 0 : diff>;
+    
+    // Now play the same game but with the tuple values instead of types
+    std::vector<std::unique_ptr<Arg>> argsVector;
+
+    // Loop over each arg with an anonymous lambda
+    ([&]
+      {
+        using Arg_T = std::decay_t<Arg_Ts>;
+
+        if constexpr (std::is_same_v<Arg, Arg_T> || std::is_same_v<ArgBuffer, Arg_T>)
+        {
+          argsVector.emplace_back(std::make_unique<Arg_T>(args));
+        }
+      }(), ...);
+
+    // Fill in missing args
+    for (size_t i = argsVector.size(); i < std::tuple_size_v<Parameter_Tuple>; i++)
+    {
+      std::string argName = "arg_" + std::to_string(i);
+      argsVector.emplace_back(std::make_unique<Arg>(argName));
+    }
+
+    auto indices = std::make_index_sequence<std::tuple_size_v<Parameter_Tuple>>{};
+    Native::create_parameters_impl<Parameter_Tuple, ArgsTuple>(result, indices, std::move(argsVector));
+    return result;
+  }
+
+  template<typename... Arg_Ts>
+  inline std::unique_ptr<Return> Native::create_return(Arg_Ts& ...args)
+  {
+    using Arg_Tuple = std::tuple<Arg_Ts...>;
+
+    constexpr std::size_t index = tuple_element_index_v<Arg_Tuple, Return, ReturnBuffer>;
+
+    std::unique_ptr<Return> result;
+
+    if constexpr (index < std::tuple_size_v<Arg_Tuple>)
+    {
+      using Return_T_Local = std::decay_t<std::tuple_element_t<index, Arg_Tuple>>;
+      const Return_T_Local& returnInfo = std::get<index>(std::forward_as_tuple(std::forward<Arg_Ts>(args)...));
+      result = std::make_unique<Return_T_Local>(returnInfo);
+    }
+    else
+    {
+      result = std::make_unique<Return>();
+    }
+
     return result;
   }
 
-  inline std::vector<std::optional<VALUE>> Native::getRubyValues(size_t argc, const VALUE* argv, bool validate)
+  inline std::map<std::string, VALUE> Native::readRubyArgs(size_t argc, const VALUE* argv)
   {
-#undef max
-    int size = std::max(this->parameters_.size(), argc);
-    std::vector<std::optional<VALUE>> result(size);
+    std::map<std::string, VALUE> result;
 
     // Keyword handling
     if (rb_keyword_given_p())
     {
       // Keywords are stored in the last element in a hash
-      int actualArgc = argc - 1;
-
-      VALUE value = argv[actualArgc];
-      Hash keywords(value);
+      size_t actualArgc = argc - 1;
 
       // Copy over leading non-keyword arguments
-      for (int i = 0; i < actualArgc; i++)
+      for (size_t i = 0; i < actualArgc; i++)
       {
-        result[i] = argv[i];
+        std::string key = "arg_" + std::to_string(i);
+        result[key] = argv[i];
       }
 
+      VALUE value = argv[actualArgc];
+      Hash keywords(value);
+
       // Copy over keyword arguments
       for (auto pair : keywords)
       {
-        Symbol key(pair.first);
-        ParameterAbstract* parameter = this->getParameterByName(key.str());
-        if (!parameter)
-        {
-          throw std::invalid_argument("Unknown keyword: " + key.str());
-        }
-
-        const Arg* arg = parameter->arg;
-
-        result[arg->position] = pair.second.value();
+        result[pair.first.to_s().str()] = pair.second.value();
       }
     }
     else
     {
-      std::copy(argv, argv + argc, result.begin());
+      // Copy over leading non-keyword arguments
+      for (size_t i = 0; i < argc; i++)
+      {
+        std::string key = "arg_" + std::to_string(i);
+        result[key] = argv[i];
+      }
     }
 
-    // Block handling. If we find a block and the last parameter is missing then
-    // set it to the block
-    if (rb_block_given_p() && result.size() > 0 && !result.back().has_value())
+    return result;
+  }
+
+  inline std::vector<std::optional<VALUE>> Native::getRubyValues(std::map<std::string, VALUE> values, bool validate)
+  {
+    // !!!NOTE!!! We copied the values parameter because we are going to modify it!
+
+    // Protect against user sending too many arguments
+    if (values.size() > this->parameters_.size())
     {
-      VALUE proc = rb_block_proc();
-      result.back() = proc;
+      std::string message = "wrong number of arguments (given " +
+        std::to_string(values.size()) + ", expected " + std::to_string(this->parameters_.size()) + ")";
+      throw std::invalid_argument(message);
     }
 
-    if (validate)
+    std::vector<std::optional<VALUE>> result(this->parameters_.size());
+
+    for (size_t i=0; i< this->parameters_.size(); i++)
     {
-      // Protect against user sending too many arguments
-      if (argc > this->parameters_.size())
+      std::unique_ptr<ParameterAbstract>& parameter = this->parameters_[i];
+      Arg* arg = parameter->arg();
+
+      // If using keywords arguments, then the value key will be arg->name(). If using positional 
+      // arguments then they key will be "arg_<position>"
+      std::string keywordKey = arg->name;
+      std::string positionKey = "arg_" + std::to_string(i);
+
+      auto iter = values.find(keywordKey);
+      if (iter == values.end() && keywordKey != positionKey)
       {
-        std::string message = "wrong number of arguments (given " +
-          std::to_string(argc) + ", expected " + std::to_string(this->parameters_.size()) + ")";
-        throw std::invalid_argument(message);
+        iter = values.find(positionKey);
       }
 
-      for (size_t i = 0; i < result.size(); i++)
+      if (iter != values.end())
+      {
+        result[i] = iter->second;
+        // Remove the value
+        values.erase(iter);
+      }
+      else if (arg->hasDefaultValue())
       {
-        std::optional<VALUE> value = result[i];
-        ParameterAbstract* parameter = this->parameters_[i].get();
+        result[i] = parameter->defaultValueRuby();
+      }
+      else if (arg->isBlock() && rb_block_given_p())
+      {
+        result[i] = protect(rb_block_proc);
+      }
+      else if (validate)
+      {
+        std::string message = "Missing argument. Name: " + arg->name + ". Index: " + std::to_string(i) + ".";
+        throw std::invalid_argument(message);
+      }
+      else
+      {
+        // No point in continuing - this native is not going to match
+        return result;
+      }
+    }
 
-        if (!parameter->arg->hasDefaultValue() && !value.has_value())
-        {
-          std::string message;
-          message = "Missing argument. Name: " + parameter->arg->name + ". Index: " + std::to_string(parameter->arg->position) + ".";
-          throw std::invalid_argument(message);
-        }
+    // Check for unknown arguments
+    if (validate && values.size() > 0)
+    {
+      // There are unknown arguments
+      std::ostringstream message;
+      message << "Unknown argument(s): ";
+      size_t count = 0;
+      for (const std::pair<const std::string, VALUE>& pair : values)
+      {
+        if (count > 0)
+          message << ", ";
+        message << pair.first;
+        count++;
       }
+      throw std::invalid_argument(message.str());
     }
 
     return result;
   }
 
-  inline Convertible Native::matchParameters(std::vector<std::optional<VALUE>>& values)
+  inline double Native::matchParameters(std::vector<std::optional<VALUE>>& values, size_t argc)
   {
-    Convertible result = Convertible::Exact;
-    for (size_t i = 0; i < this->parameters_.size(); i++)
+    // Only score arguments actually passed (not defaults)
+    double minScore = Convertible::Exact;
+
+    for (size_t i = 0; i < argc && i < this->parameters_.size(); i++)
     {
       ParameterAbstract* parameter = this->parameters_[i].get();
       std::optional<VALUE>& value = values[i];
-      result = result & parameter->matches(value);
+      double score = parameter->matches(value);
+      minScore = (std::min)(minScore, score);
     }
-    return result;
+
+    return minScore;
   }
 
-  inline Resolved Native::matches(size_t argc, const VALUE* argv, VALUE self)
+  inline Resolved Native::matches(std::map<std::string, VALUE>& values)
   {
-    // Return false if Ruby provided more arguments than the C++ method takes
-    if (argc > this->parameters_.size())
-      return Resolved{ Convertible::None, 0, this };
-
-    Resolved result{ Convertible::Exact, 1, this };
+    // Return Convertible::None if Ruby provided more arguments than the C++ method takes
+    if (values.size() > this->parameters_.size())
+    {
+      return Resolved{ Convertible::None, this };
+    }
 
-    std::vector<std::optional<VALUE>> rubyValues = this->getRubyValues(argc, argv, false);
-    result.convertible = this->matchParameters(rubyValues);
+    // Get Ruby values for each parameter and see how they match
+    std::vector<std::optional<VALUE>> rubyValues = this->getRubyValues(values, false);
+    double minScore = this->matchParameters(rubyValues, values.size());
 
-    if (this->parameters_.size() > 0)
+    // If zero score return then stop
+    if (minScore == 0)
     {
-      int providedValues = std::count_if(rubyValues.begin(), rubyValues.end(), [](std::optional<VALUE>& value)
-        {
-          return value.has_value();
-        });
+      return Resolved{ Convertible::None, this };
+    }
 
-      result.parameterMatch = providedValues / (double)this->parameters_.size();
+    // How many actual values do we have?
+    size_t actualValuesCount = std::count_if(rubyValues.begin(), rubyValues.end(),
+      [](std::optional<VALUE>& optional)
+      {
+        return optional.has_value();
+      });
+
+    // If we don't have enough parameters return
+    if (actualValuesCount < this->parameters_.size())
+      return Resolved{ Convertible::None, this };
+
+    // Penalize use of default parameters
+    double parameterMatch = Convertible::Exact;
+    size_t defaultParameterCount = actualValuesCount - values.size();
+    for (size_t i = 0; i < defaultParameterCount; i++)
+    {
+      parameterMatch *= 0.99;  // Small penalty per default used
     }
-    return result;
+
+    // Final score: minScore * parameterMatch
+    double finalScore = minScore * parameterMatch;
+
+    return Resolved{ finalScore, this };
   }
 
   inline std::vector<const ParameterAbstract*> Native::parameters()