More gdb::optional features

Currently we can't use gdb::optional<T> as function return type,
because gdb::optional's copy ctor is deleted.  For example, with:

  gdb::optional<int> function ()
  {
    gdb::optional<int> opt;
    ....
    return opt;

we get:

  src/gdb/foo.c: In function ‘gdb::optional<int> foo()’:
  src/gdb/foo.c:75:10: error: use of deleted function ‘gdb::optional<T>::optional(const gdb::optional<T>&) [with T = int]’
     return opt;
	    ^
  In file included from src/gdb/foo.c:68:0:
  src/gdb/common/gdb_optional.h:53:3: note: declared here
     optional (const optional &other) = delete;
     ^

I started by fixing that, and then ran into another missing feature,
also fixed by this patch.

The next feature I'm missing most from gdb::optional<T> compared to
std::optional<T> is construction/move/assignment from a T, instead of
having to default construct an gdb::optional and then use
optional::emplace(....).

For example:
  gdb::optional<std::string> function ()
  {
    gdb::optional<std::string> opt;
    std::string str;
    ...
    opt.emplace (std::move (str));
    return opt;
vs
  gdb::optional<std::string> function ()
  {
    std::string str;
    ...
    return str;

The copy/move ctor/assign methods weren't initialy implemented because
std::optional supports construction from a type U if U is convertible
to T too, and has rules to decide whether the ctors are
explicit/implicit based on that, and rules for whether the ctor should
be trivial or not, etc., which leads to a much more complicated
implementation.

If we stick to supporting copy/move construction/assignment of/to an
optional<T> from exactly only optional<T> and T, then all that
conversion-related complication disappears, and we still gain
convenience in most use cases.

The patch also makes emplace return a reference to the constructor
object, per C++17 std::optional, and adds a reset method, againt
because std::optional has one and it's trivial to support it.  These
two changes are a requirement of the gdb::optional unit testing patch
that will follow.

gdb/ChangeLog:
2017-04-18  Pedro Alves  <palves@redhat.com>

	* common/gdb_optional.h: Include common/traits.h.
	(in_place_t): New type.
	(in_place): New constexpr variable.
	(optional::optional): Remove member initialization of
	m_instantiated.
	(optional::optional(in_place_t...)): New constructor.
	(optional::~optional): Use reset.
	(optional::optional(const optional&)): New.
	(optional::optional(const optional&&)): New.
	(optional::optional(T &)): New.
	(optional::optional(T &&)): New.
	(operator::operator=(const optional &)): New.
	(operator::operator=(optional &&)): New.
	(operator::operator= (const T &))
	(operator::operator= (T &&))
	(operator::emplace (Args &&... args)): Return a T&.  Use reset.
	(operator::reset): New.
	(operator::m_instantiated):: Add in-class initializer.
	* common/traits.h: Include <type_traits>.
	(struct And): New types.

2 files changed, 143 insertions, 15 deletions

diff --git a/gdb/common/gdb_optional.h b/gdb/common/gdb_optional.h
index ad1119f..c30fa5b 100644
--- a/gdb/common/gdb_optional.h
+++ b/gdb/common/gdb_optional.h
@@ -20,46 +20,141 @@
 #ifndef GDB_OPTIONAL_H
 #define GDB_OPTIONAL_H
 
+#include "common/traits.h"
+
 namespace gdb
 {
 
+struct in_place_t
+{
+  explicit in_place_t () = default;
+};
+
+constexpr gdb::in_place_t in_place {};
+
 /* This class attempts to be a compatible subset of std::optional,
    which is slated to be available in C++17.  This class optionally
    holds an object of some type -- by default it is constructed not
    holding an object, but later the object can be "emplaced".  This is
    similar to using std::unique_ptr, but in-object allocation is
-   guaranteed.  */
+   guaranteed.
+
+   Unlike std::optional, we currently only support copy/move
+   construction/assignment of an optional<T> from either exactly
+   optional<T> or T.  I.e., we don't support copy/move
+   construction/assignment from optional<U> or U, when U is a type
+   convertible to T.  Making that work depending on the definitions of
+   T and U is somewhat complicated, and currently the users of this
+   class don't need it.  */
+
 template<typename T>
 class optional
 {
 public:
 
   constexpr optional ()
-    : m_dummy (),
-      m_instantiated (false)
+    : m_dummy ()
+  {}
+
+  template<typename... Args>
+  constexpr optional (in_place_t, Args &&... args)
+    : m_item (std::forward<Args> (args)...),
+      m_instantiated (true)
+  {}
+
+  ~optional ()
+  { this->reset (); }
+
+  /* Copy and move constructors.  */
+
+  optional (const optional &other)
   {
+    if (other.m_instantiated)
+      this->emplace (other.get ());
   }
 
-  ~optional ()
+  optional (optional &&other)
+    noexcept(std::is_nothrow_move_constructible<T> ())
+  {
+    if (other.m_instantiated)
+      this->emplace (std::move (other.get ()));
+  }
+
+  constexpr optional (const T &other)
+    : m_item (other),
+      m_instantiated (true)
+  {}
+
+  constexpr optional (T &&other)
+    noexcept (std::is_nothrow_move_constructible<T> ())
+    : m_item (std::move (other)),
+      m_instantiated (true)
+  {}
+
+  /* Assignment operators.  */
+
+  optional &
+  operator= (const optional &other)
+  {
+    if (m_instantiated && other.m_instantiated)
+      this->get () = other.get ();
+    else
+      {
+	if (other.m_instantiated)
+	  this->emplace (other.get ());
+	else
+	  this->reset ();
+      }
+
+    return *this;
+  }
+
+  optional &
+  operator= (optional &&other)
+    noexcept (And<std::is_nothrow_move_constructible<T>,
+	      std::is_nothrow_move_assignable<T>> ())
+  {
+    if (m_instantiated && other.m_instantiated)
+      this->get () = std::move (other.get ());
+    else
+      {
+	if (other.m_instantiated)
+	  this->emplace (std::move (other.get ()));
+	else
+	  this->reset ();
+      }
+    return *this;
+  }
+
+  optional &
+  operator= (const T &other)
   {
     if (m_instantiated)
-      destroy ();
+      this->get () = other;
+    else
+      this->emplace (other);
+    return *this;
   }
 
-  /* These aren't deleted in std::optional, but it was simpler to
-     delete them here, because currently the users of this class don't
-     need them, and making them depend on the definition of T is
-     somewhat complicated.  */
-  optional (const optional &other) = delete;
-  optional<T> &operator= (const optional &other) = delete;
+  optional &
+  operator= (T &&other)
+    noexcept (And<std::is_nothrow_move_constructible<T>,
+	      std::is_nothrow_move_assignable<T>> ())
+  {
+    if (m_instantiated)
+      this->get () = std::move (other);
+    else
+      this->emplace (std::move (other));
+    return *this;
+  }
 
   template<typename... Args>
-  void emplace (Args &&... args)
+  T &emplace (Args &&... args)
   {
-    if (m_instantiated)
-      destroy ();
+    this->reset ();
     new (&m_item) T (std::forward<Args>(args)...);
     m_instantiated = true;
+    return this->get ();
   }
 
   /* Observers.  */
@@ -87,6 +182,13 @@ public:
   constexpr bool has_value () const noexcept
   { return m_instantiated; }
 
+  /* 'reset' is a 'safe' operation with no precondition.  */
+  void reset () noexcept
+  {
+    if (m_instantiated)
+      this->destroy ();
+  }
+
 private:
 
   /* Destroy the object.  */
@@ -109,7 +211,7 @@ private:
   };
 
   /* True if the object was ever emplaced.  */
-  bool m_instantiated;
+  bool m_instantiated = false;
 };
 
 }
diff --git a/gdb/common/traits.h b/gdb/common/traits.h
index 4b7bac3..c8f29cc 100644
--- a/gdb/common/traits.h
+++ b/gdb/common/traits.h
@@ -18,6 +18,8 @@
 #ifndef COMMON_TRAITS_H
 #define COMMON_TRAITS_H
 
+#include <type_traits>
+
 namespace gdb {
 
 /* Pre C++14-safe (CWG 1558) version of C++17's std::void_t.  See
@@ -29,6 +31,30 @@ struct make_void { typedef void type; };
 template<typename... Ts>
 using void_t = typename make_void<Ts...>::type;
 
+/* A few trait helpers, mainly stolen from libstdc++.  Uppercase
+   because "and" is a keyword.  */
+
+template<typename...>
+struct And;
+
+template<>
+struct And<> : public std::true_type
+{};
+
+template<typename B1>
+struct And<B1> : public B1
+{};
+
+template<typename B1, typename B2>
+struct And<B1, B2>
+  : public std::conditional<B1::value, B2, B1>::type
+{};
+
+template<typename B1, typename B2, typename B3, typename... Bn>
+struct And<B1, B2, B3, Bn...>
+  : public std::conditional<B1::value, And<B2, B3, Bn...>, B1>::type
+{};
+
 }
 
 #endif /* COMMON_TRAITS_H */