use forward instead of move for universal references

Summary:When dealing with universal references, std::move will move from
objects that are passed as lvalue references. Instead std::forward
should be used, which only moves from an object if it's passed
as rvalue reference.

Reviewed By: yfeldblum

Differential Revision: D3200402

fb-gh-sync-id: 14be071e8498dd64cb8b2583c0cc2dd383bfebb8
fbshipit-source-id: 14be071e8498dd64cb8b2583c0cc2dd383bfebb8

folly/Conv.h

@@ -78,7 +78,7 @@ to(const Src & value) {
 template <class Tgt, class Src>
 typename std::enable_if<std::is_same<Tgt, Src>::value, Tgt>::type
 to(Src && value) {
-  return std::move(value);
+  return std::forward<Src>(value);
 }
 
 /*******************************************************************************

folly/Subprocess.h

@@ -662,7 +662,7 @@ class Subprocess {
       uint64_t maxLineLength = 0,  // No line length limit by default
       char delimiter = '\n',
       uint64_t bufSize = 1024
-    ) : fdLineCb_(std::move(fdLineCb)),
+    ) : fdLineCb_(std::forward<Callback>(fdLineCb)),
         maxLineLength_(maxLineLength),
         delimiter_(delimiter),
         bufSize_(bufSize) {}

folly/futures/Future.h

@@ -331,7 +331,7 @@ class Future {
   template <class E>
   void raise(E&& exception) {
     raise(make_exception_wrapper<typename std::remove_reference<E>::type>(
-        std::move(exception)));
+        std::forward<E>(exception)));
   }
 
   /// Raise an interrupt. If the promise holder has an interrupt

folly/test/ApplyTupleTest.cpp

@@ -84,8 +84,8 @@ typedef GuardObjBase const& Guard;
 template<class F, class Tuple>
 struct GuardObj : GuardObjBase {
   explicit GuardObj(F&& f, Tuple&& args)
-    : f_(std::move(f))
-    , args_(std::move(args))
+    : f_(std::forward<F>(f))
+    , args_(std::forward<Tuple>(args))
   {}
   GuardObj(GuardObj&& g) noexcept
     : GuardObjBase(std::move(g))

folly/test/MPMCQueueTest.cpp

@@ -104,7 +104,7 @@ TEST(MPMCQueue, sequencer_deterministic) {
 template <typename T>
 void runElementTypeTest(T&& src) {
   MPMCQueue<T> cq(10);
-  cq.blockingWrite(std::move(src));
+  cq.blockingWrite(std::forward<T>(src));
   T dest;
   cq.blockingRead(dest);
   EXPECT_TRUE(cq.write(std::move(dest)));