build: remove last llvm:: reference in stdlib

This removes the last reference to the `llvm::` namespace in the
standard library.  All uses of the LLVMSupport library now are
namespaced into the `__swift::__runtime` namespace.  This allows us to
incrementally vend the LLVMSupport library and make the separation
explicit.

Author: compnerd

include/swift/ABI/TypeIdentity.h

@@ -184,7 +184,7 @@ class ParsedTypeIdentity {
   StringRef FullIdentity;
 
   /// Any extended information that type might have.
-  Optional<TypeImportInfo<StringRef>> ImportInfo;
+  llvm::Optional<TypeImportInfo<StringRef>> ImportInfo;
 
   /// The ABI name of the type.
   StringRef getABIName() const {

include/swift/Basic/LLVM.h

@@ -45,7 +45,9 @@ namespace llvm {
   template<typename T> class MutableArrayRef;
 #endif
   template<typename T> class TinyPtrVector;
+#if !defined(swiftCore_EXPORTS)
   template<typename T> class Optional;
+#endif
   template <typename ...PTs> class PointerUnion;
   template <typename IteratorT> class iterator_range;
   class SmallBitVector;
@@ -75,7 +77,9 @@ namespace swift {
 #endif
   using llvm::iterator_range;
   using llvm::None;
+#if !defined(swiftCore_EXPORTS)
   using llvm::Optional;
+#endif
   using llvm::PointerUnion;
   using llvm::SmallBitVector;
   using llvm::SmallPtrSet;

include/swift/Basic/STLExtras.h

@@ -528,19 +528,18 @@ makeOptionalTransformRange(Range range, OptionalTransform op) {
 /// the result in an optional to indicate success or failure.
 template<typename Subclass>
 struct DowncastAsOptional {
-  template<typename Superclass>
+  template <typename Superclass>
   auto operator()(Superclass &value) const
-         -> Optional<decltype(llvm::cast<Subclass>(value))> {
+      -> llvm::Optional<decltype(llvm::cast<Subclass>(value))> {
     if (auto result = llvm::dyn_cast<Subclass>(value))
       return result;
 
     return None;
   }
 
-  template<typename Superclass>
+  template <typename Superclass>
   auto operator()(const Superclass &value) const
-         -> Optional<decltype(llvm::cast<Subclass>(value))>
-  {
+      -> llvm::Optional<decltype(llvm::cast<Subclass>(value))> {
     if (auto result = llvm::dyn_cast<Subclass>(value))
       return result;
 

include/swift/Demangling/TypeDecoder.h

@@ -94,7 +94,7 @@ enum class ImplParameterDifferentiability {
   NotDifferentiable
 };
 
-static inline Optional<ImplParameterDifferentiability>
+static inline llvm::Optional<ImplParameterDifferentiability>
 getDifferentiabilityFromString(StringRef string) {
   if (string.empty())
     return ImplParameterDifferentiability::DifferentiableOrNotApplicable;
@@ -115,7 +115,7 @@ class ImplFunctionParam {
   using ConventionType = ImplParameterConvention;
   using DifferentiabilityType = ImplParameterDifferentiability;
 
-  static Optional<ConventionType>
+  static llvm::Optional<ConventionType>
   getConventionFromString(StringRef conventionString) {
     if (conventionString == "@in")
       return ConventionType::Indirect_In;
@@ -168,7 +168,7 @@ class ImplFunctionResult {
 public:
   using ConventionType = ImplResultConvention;
 
-  static Optional<ConventionType>
+  static llvm::Optional<ConventionType>
   getConventionFromString(StringRef conventionString) {
     if (conventionString == "@out")
       return ConventionType::Indirect;
@@ -268,8 +268,8 @@ class ImplFunctionTypeFlags {
 #if SWIFT_OBJC_INTEROP
 /// For a mangled node that refers to an Objective-C class or protocol,
 /// return the class or protocol name.
-static inline Optional<StringRef> getObjCClassOrProtocolName(
-    NodePointer node) {
+static inline llvm::Optional<StringRef>
+getObjCClassOrProtocolName(NodePointer node) {
   if (node->getKind() != Demangle::Node::Kind::Class &&
       node->getKind() != Demangle::Node::Kind::Protocol)
     return None;
@@ -435,7 +435,7 @@ class TypeDecoder {
     case NodeKind::Metatype:
     case NodeKind::ExistentialMetatype: {
       unsigned i = 0;
-      Optional<ImplMetatypeRepresentation> repr;
+      llvm::Optional<ImplMetatypeRepresentation> repr;
 
       // Handle lowered metatypes in a hackish way. If the representation
       // was not thin, force the resulting typeref to have a non-empty
@@ -650,7 +650,7 @@ class TypeDecoder {
         }
       }
 
-      Optional<ImplFunctionResult<BuiltType>> errorResult;
+      llvm::Optional<ImplFunctionResult<BuiltType>> errorResult;
       switch (errorResults.size()) {
       case 0:
         break;
@@ -905,7 +905,7 @@ class TypeDecoder {
       return true;
 
     StringRef conventionString = node->getChild(0)->getText();
-    Optional<typename T::ConventionType> convention =
+    llvm::Optional<typename T::ConventionType> convention =
         T::getConventionFromString(conventionString);
     if (!convention)
       return true;
@@ -1072,8 +1072,8 @@ class TypeDecoder {
       return true;
     };
 
-    auto decodeParam = [&](NodePointer paramNode)
-        -> Optional<FunctionParam<BuiltType>> {
+    auto decodeParam =
+        [&](NodePointer paramNode) -> llvm::Optional<FunctionParam<BuiltType>> {
       if (paramNode->getKind() != NodeKind::TupleElement)
         return None;
 

include/swift/Reflection/TypeRefBuilder.h

@@ -248,8 +248,9 @@ class TypeRefBuilder {
 
 public:
   using BuiltType = const TypeRef *;
-  using BuiltTypeDecl = Optional<std::string>;
-  using BuiltProtocolDecl = Optional<std::pair<std::string, bool /*isObjC*/>>;
+  using BuiltTypeDecl = llvm::Optional<std::string>;
+  using BuiltProtocolDecl =
+      llvm::Optional<std::pair<std::string, bool /*isObjC*/>>;
 
   TypeRefBuilder(const TypeRefBuilder &other) = delete;
   TypeRefBuilder &operator=(const TypeRefBuilder &other) = delete;
@@ -295,8 +296,7 @@ class TypeRefBuilder {
     return BuiltinTypeRef::create(*this, mangledName);
   }
 
-  Optional<std::string>
-  createTypeDecl(Node *node, bool &typeAlias) {
+  llvm::Optional<std::string> createTypeDecl(Node *node, bool &typeAlias) {
     return Demangle::mangleNode(node);
   }
 
@@ -310,25 +310,25 @@ class TypeRefBuilder {
     return std::make_pair(name, true);
   }
 
-  Optional<std::string> createTypeDecl(std::string &&mangledName,
-                                       bool &typeAlias) {
+  llvm::Optional<std::string> createTypeDecl(std::string &&mangledName,
+                                             bool &typeAlias) {
     return std::move(mangledName);
   }
-  
-  const NominalTypeRef *createNominalType(
-                                    const Optional<std::string> &mangledName) {
+
+  const NominalTypeRef *
+  createNominalType(const llvm::Optional<std::string> &mangledName) {
     return NominalTypeRef::create(*this, *mangledName, nullptr);
   }
 
-  const NominalTypeRef *createNominalType(
-                                    const Optional<std::string> &mangledName,
-                                    const TypeRef *parent) {
+  const NominalTypeRef *
+  createNominalType(const llvm::Optional<std::string> &mangledName,
+                    const TypeRef *parent) {
     return NominalTypeRef::create(*this, *mangledName, parent);
   }
 
-  const TypeRef *createTypeAliasType(
-                                    const Optional<std::string> &mangledName,
-                                    const TypeRef *parent) {
+  const TypeRef *
+  createTypeAliasType(const llvm::Optional<std::string> &mangledName,
+                      const TypeRef *parent) {
     // TypeRefs don't contain sugared types
     return nullptr;
   }
@@ -354,13 +354,13 @@ class TypeRefBuilder {
   }
 
   const BoundGenericTypeRef *
-  createBoundGenericType(const Optional<std::string> &mangledName,
+  createBoundGenericType(const llvm::Optional<std::string> &mangledName,
                          const std::vector<const TypeRef *> &args) {
     return BoundGenericTypeRef::create(*this, *mangledName, args, nullptr);
   }
 
   const BoundGenericTypeRef *
-  createBoundGenericType(const Optional<std::string> &mangledName,
+  createBoundGenericType(const llvm::Optional<std::string> &mangledName,
                          llvm::ArrayRef<const TypeRef *> args,
                          const TypeRef *parent) {
     return BoundGenericTypeRef::create(*this, *mangledName, args, parent);
@@ -420,7 +420,7 @@ class TypeRefBuilder {
       Demangle::ImplParameterConvention calleeConvention,
       llvm::ArrayRef<Demangle::ImplFunctionParam<const TypeRef *>> params,
       llvm::ArrayRef<Demangle::ImplFunctionResult<const TypeRef *>> results,
-      Optional<Demangle::ImplFunctionResult<const TypeRef *>> errorResult,
+      llvm::Optional<Demangle::ImplFunctionResult<const TypeRef *>> errorResult,
       ImplFunctionTypeFlags flags) {
     // Minimal support for lowered function types. These come up in
     // reflection as capture types. For the reflection library's
@@ -467,14 +467,15 @@ class TypeRefBuilder {
                                               isClassBound);
   }
 
-  const ExistentialMetatypeTypeRef *
-  createExistentialMetatypeType(const TypeRef *instance,
-                    Optional<Demangle::ImplMetatypeRepresentation> repr=None) {
+  const ExistentialMetatypeTypeRef *createExistentialMetatypeType(
+      const TypeRef *instance,
+      llvm::Optional<Demangle::ImplMetatypeRepresentation> repr = None) {
     return ExistentialMetatypeTypeRef::create(*this, instance);
   }
 
-  const MetatypeTypeRef *createMetatypeType(const TypeRef *instance,
-                    Optional<Demangle::ImplMetatypeRepresentation> repr=None) {
+  const MetatypeTypeRef *createMetatypeType(
+      const TypeRef *instance,
+      llvm::Optional<Demangle::ImplMetatypeRepresentation> repr = None) {
     bool WasAbstract = (repr && *repr != ImplMetatypeRepresentation::Thin);
     return MetatypeTypeRef::create(*this, instance, WasAbstract);
   }