Add base::get to support rvalue-reference tuple

base/tuple.h

Index: base/tuple.h
diff --git a/base/tuple.h b/base/tuple.h
index 62344a1233916317b5ff96659fc5370daa5c4260..e82f2e5f06ad8860f722879b44bfef1e150c23f1 100644
--- a/base/tuple.h
+++ b/base/tuple.h
@@ -104,6 +104,20 @@ struct MakeIndexSequenceImpl<N, Ns...>
 
 #endif  // defined(OS_WIN) && defined(_PREFAST_)
 
+// std::get() in <=libstdc++-4.6 returns an lvalue-reference for
+// rvalue-reference of a tuple, where an rvalue-reference is expected.
+template <size_t I, typename... Ts>
+typename std::tuple_element<I, std::tuple<Ts...>>::type&& get(
+    std::tuple<Ts...>&& t) {
+  using ElemType = typename std::tuple_element<I, std::tuple<Ts...>>::type;
+  return std::forward<ElemType>(std::get<I>(t));

[danakj, 2016/06/14 18:54:07]

Why forward instead of move?

Trying to compare to
https://github.com/llvm-mirror/libcxx/blob/master/include/tuple#L979, though
you're using std::get() here of course. They static cast to ElemType&&.

It seems to work with forward from the tests, but if move is the same in all
cases, I prefer that.

[tzik, 2016/06/14 22:34:52]

This is needed when the ElemType is a lvalue-reference.
In the case below:
  int i = 0;
  base::get(std::tie(i));
std::tie(i) returns std::tuple<int&>&&, and base::get should return `int&`.
If we use std::move in the base::get impl, the return type will be `int&&` and
|i| above will be moved unexpectedly.

[danakj, 2016/06/17 22:55:12]

Hm. But isn't the return type already hardcoded to type&& above? And in the
example you gave, it would use the get() method below this to simply forward to
std::get()?

[tzik, 2016/06/21 08:46:33]

I added a test case to reveal std::move doesn't work here: the previous ones
test only decltype() of base::get(), and didn't catch the compilation error in
the impl of base::get().

Though `type&&` looks like a rvalue-reference, it can be lvalue-reference when
|type| is already a lvalue-reference.
  using T = int&;
  static_assert(std::is_same<int&, T&&>::value, "");

In my previous example, since std::tie() returns the tuple by value, the first
overload of base::get() handles it rather than the second.

+}
+
+template <size_t I, typename T>
+auto get(T& t) -> decltype(std::get<I>(t)) {
+  return std::get<I>(t);
+}
+
 template <size_t N>
 using MakeIndexSequence = typename MakeIndexSequenceImpl<N>::Type;