fix for assisted reference type arguments of factories

2 files changed, 35 insertions, 3 deletions

diff --git a/include/fruit/impl/component_functors.defn.h b/include/fruit/impl/component_functors.defn.h
index aac6307..3db690c 100644
--- a/include/fruit/impl/component_functors.defn.h
+++ b/include/fruit/impl/component_functors.defn.h
@@ -402,7 +402,7 @@ template <int numAssistedBefore, int numNonAssistedBefore, typename Arg>
 struct GetAssistedArg<numAssistedBefore, numNonAssistedBefore, Assisted<Arg>> {
   template <typename InjectedArgsTuple, typename UserProvidedArgsTuple>
   inline Arg operator()(InjectedArgsTuple&, UserProvidedArgsTuple& user_provided_args) {
-    return std::move(std::get<numAssistedBefore>(user_provided_args));
+    return std::forward<typename std::tuple_element<numAssistedBefore, UserProvidedArgsTuple>::type>(std::get<numAssistedBefore>(user_provided_args));
   }
 };
 
@@ -439,8 +439,8 @@ struct RegisterFactoryHelper {
 
       explicit ObjectProvider(std::tuple<NakedInjectedArgs...>&& injected_args) : injected_args(std::move(injected_args)) {}
 
-      NakedC operator()(NakedUserProvidedArgs... params) {
-        std::tuple<NakedUserProvidedArgs...> user_provided_args = std::tuple<NakedUserProvidedArgs...>(std::move(params)...);
+      NakedC operator()(NakedUserProvidedArgs&&... params) {
+        auto user_provided_args = std::forward_as_tuple(std::forward<decltype(params)>(params)...);
         // These are unused if they are 0-arg tuples. Silence the unused-variable warnings anyway.
         (void)injected_args;
         (void)user_provided_args;
diff --git a/tests/test_register_factory.py b/tests/test_register_factory.py
index 8f62946..9cdf27d 100755
--- a/tests/test_register_factory.py
+++ b/tests/test_register_factory.py
@@ -389,6 +389,38 @@ class TestRegisterFactory(parameterized.TestCase):
             COMMON_DEFINITIONS,
             source)
 
+    def test_autoinject_assisted_params_ref(self):
+        source = '''
+            struct Foo {
+              Foo(int x, float y, char z) {
+                (void)x;
+                (void)y;
+                (void)z;
+              }
+            };
+    
+            using FooFactory = std::function<Foo(int&, float&&, char)>;
+    
+            fruit::Component<FooFactory> getComponent() {
+              return fruit::createComponent()
+                  .registerFactory<Foo(fruit::Assisted<int&>, fruit::Assisted<float&&>, fruit::Assisted<char> z)>(
+                      [](int& x, float&& y, z) {
+                        return Foo(x, std::move(y), z);
+                      });
+            }
+    
+            int main() {
+              fruit::Injector<FooFactory> injector(getComponent);
+              FooFactory fooFactory(injector);
+              int x = 1;
+              Foo foo = fooFactory(x, 2.3f, 'z');
+              (void)foo;
+            }
+            '''
+        expect_success(
+            COMMON_DEFINITIONS,
+            source)
+
     def test_autoinject_2_assisted_params_returning_value(self):
         source = '''
             struct Foo {