Replace swift::Optional with llvm::Optional.

There are some compatibility aliases here that will go away after the switch.

Swift SVN r22474

Author: jrose-apple

include/swift/Basic/Optional.h

@@ -25,176 +25,13 @@
 #define SWIFT_BASIC_OPTIONAL_H
 
 #include "llvm/ADT/Optional.h"
-#include <type_traits>
-#include <utility>
-#include <cassert>
 
 namespace swift {
-  /// An enum whose purpose is to make it easier to initialize an
-  /// empty optional.
-  static const enum class Nothing_t { Nothing } Nothing = Nothing_t::Nothing;
+  static auto Nothing = llvm::None;
+  using Nothing_t = decltype(Nothing);
 
-  static_assert(!std::is_convertible<Nothing_t, bool>::value,
-                "Nothing must not be implicitly convertible to bool");
-  
-  template<typename T>
-  class Optional {
-    // Place Value in an anonymous union to suppress implicit value semantics.
-    union {
-      T Value;
-    };
-    unsigned HasValue : 1;
-    
-  public:
-    typedef T value_type;
-
-    /// \brief Construct an empty instance.
-    Optional() : HasValue(false) { }
-
-    /// \brief Construct an empty instance.
-    Optional(Nothing_t _) : HasValue(false) { }
-    
-    /// \brief Construct an instance containing a value of type \c T
-    /// constructed with the given arguments.
-    ///
-    /// \param Args The arguments with which the \c T object will be
-    /// direct-initialized.
-    template<typename ...ArgTypes>
-    Optional(ArgTypes &&...Args)
-      : Value(std::forward<ArgTypes>(Args)...), HasValue(true)
-    {
-    }
-
-    Optional(const llvm::Optional<T> &other) : HasValue(false) {
-      if (other)
-        emplace(*other);
-    }
-
-    Optional(llvm::Optional<T> &&other) : HasValue(false) {
-      if (other)
-        emplace(std::move(*other));
-    }
-
-    Optional(Optional &Other) : HasValue(Other.HasValue) {
-      if (HasValue)
-        ::new ((void*)&Value) T(Other.Value);
-    }
-
-    Optional(const Optional &Other) : HasValue(Other.HasValue) {
-      if (HasValue)
-        ::new ((void*)&Value) T(Other.Value);
-    }
-    
-    Optional(Optional &&Other) : HasValue(Other.HasValue) {
-      if (HasValue) {
-        ::new ((void*)&Value) T(std::move(Other.Value));
-        Other.HasValue = false;
-      }
-    }
-    
-    Optional &operator=(const Optional &Other) {
-      if (HasValue && Other.HasValue) {
-        Value = Other.Value;
-        return *this;
-      }
-      
-      if (HasValue) {
-        reset();
-        return *this;
-      }
-      
-      if (Other.HasValue) {
-        HasValue = true;
-        ::new ((void*)&Value) T(Other.Value);
-      }
-      
-      return *this;
-    }
-    
-    Optional &operator=(Optional &&Other) {
-      if (HasValue && Other.HasValue) {
-        Value = std::move(Other.Value);
-        Other.reset();
-        return *this;
-      }
-      
-      if (HasValue) {
-        reset();
-        return *this;
-      }
-      
-      if (Other.HasValue) {
-        HasValue = true;
-        ::new ((void*)&Value) T(std::move(Other.Value));
-        Other.reset();
-      }
-      
-      return *this;
-    }
-    
-    ~Optional() { reset(); }
-
-    // Create a new object by constructing it in place with the given arguments.
-    template<typename ...ArgTypes>
-    void emplace(ArgTypes &&...Args) {
-      reset();
-      HasValue = true;
-      ::new ((void*)&Value) T(std::forward<ArgTypes>(Args)...);
-    }
-
-    void reset() {
-      if (!HasValue)
-        return;
-      
-      Value.~T();
-      HasValue = false;
-    }
-    
-    T &getValue() & { assert(HasValue); return Value; }
-    const T &getValue() const & { assert(HasValue); return Value; }
-    
-    T getValue() && {
-      assert(HasValue);
-      T result = std::move(Value);
-      reset();
-      return result;
-    }
-
-    template <typename U>
-    constexpr T getValueOr(U &&value) const & {
-      return hasValue() ? getValue() : value;
-    }
-
-    template <typename U>
-    T getValueOr(U &&value) && {
-      return hasValue() ? getValue() : value;
-    }
-
-    bool hasValue() const { return HasValue; }
-    explicit operator bool() const { return HasValue; }
-    
-    const T* operator->() const { assert(HasValue); return &Value; }
-          T* operator->()       { assert(HasValue); return &Value; }
-    const T& operator*() const & { assert(HasValue); return Value; }
-          T& operator*() &       { assert(HasValue); return Value; }
-    
-    T operator*() && {
-      assert(HasValue);
-      T result = std::move(Value);
-      reset();
-      return result;
-    }
-    
-    /// Return the value inside the optional if populated; otherwise, execute
-    /// the given block, store its result inside the optional, and return it.
-    template<typename NullaryFunctor>
-    T const &cache(NullaryFunctor &&f) {
-      if (hasValue())
-        return getValue();
-      emplace(f());
-      return getValue();
-    }
-  };
+  template <typename T>
+  using Optional = llvm::Optional<T>;
 }
 
 #endif

lib/IRGen/GenFunc.h

@@ -23,7 +23,6 @@
 namespace swift {
   class ApplyInst;
   class FuncDecl;
-  template <class T> class Optional;
   enum class ResilienceExpansion : unsigned;
   class Substitution;
   class SILType;

lib/IRGen/GenObjC.h

@@ -17,6 +17,8 @@
 #ifndef SWIFT_IRGEN_GENOBJC_H
 #define SWIFT_IRGEN_GENOBJC_H
 
+#include "swift/Basic/Optional.h"
+
 namespace llvm {
   class Type;
   class Value;

lib/IRGen/IRGenFunction.h

@@ -19,6 +19,7 @@
 #define SWIFT_IRGEN_IRGENFUNCTION_H
 
 #include "swift/Basic/LLVM.h"
+#include "swift/Basic/Optional.h"
 #include "swift/AST/Type.h"
 #include "swift/SIL/SILLocation.h"
 #include "llvm/ADT/DenseMap.h"
@@ -42,7 +43,6 @@ namespace swift {
   class FuncDecl;
   class EnumElementDecl;
   class EnumType;
-  template<typename T> class Optional;
   class Pattern;
   class PatternBindingDecl;
   class SILDebugScope;