[AST] Augment OpaqueTypeDecl to store conditionally available alternatives

In preparation to support cases like this:

```
func test() -> some P {
  if #available(...) {
    return X()
  }

  return Y()
}
```

where both `X` and `Y` conform to `P` but are different types.

Author: xedin

include/swift/AST/Decl.h

@@ -19,6 +19,7 @@
 
 #include "swift/AST/AccessScope.h"
 #include "swift/AST/Attr.h"
+#include "swift/AST/Availability.h"
 #include "swift/AST/CaptureInfo.h"
 #include "swift/AST/ClangNode.h"
 #include "swift/AST/ConcreteDeclRef.h"
@@ -2786,6 +2787,40 @@ class OpaqueTypeDecl final :
     private llvm::TrailingObjects<OpaqueTypeDecl, OpaqueReturnTypeRepr *> {
   friend TrailingObjects;
 
+public:
+  /// A set of substitutions that represents a possible underlying type iff
+  /// associated set of availability conditions is met.
+  class ConditionallyAvailableSubstitutions;
+
+private:
+  /// A container to keep a set of conditional available underlying type
+  /// substitutions with their availability conditions.
+  class ConditionalAlternatives final
+      : private llvm::TrailingObjects<ConditionalAlternatives,
+                                      ConditionallyAvailableSubstitutions *> {
+    friend TrailingObjects;
+
+    unsigned NumAlternatives;
+
+    ConditionalAlternatives(
+        ArrayRef<ConditionallyAvailableSubstitutions *> underlyingTypes)
+        : NumAlternatives(underlyingTypes.size()) {
+      std::uninitialized_copy(
+          underlyingTypes.begin(), underlyingTypes.end(),
+          getTrailingObjects<ConditionallyAvailableSubstitutions *>());
+    }
+
+  public:
+    ArrayRef<ConditionallyAvailableSubstitutions *> getAlternatives() const {
+      return {getTrailingObjects<ConditionallyAvailableSubstitutions *>(),
+              NumAlternatives};
+    }
+
+    static ConditionalAlternatives *
+    get(ASTContext &ctx,
+        ArrayRef<ConditionallyAvailableSubstitutions *> underlyingTypes);
+  };
+
   /// The original declaration that "names" the opaque type. Although a specific
   /// opaque type cannot be explicitly named, oapque types can propagate
   /// arbitrarily through expressions, so we need to know *which* opaque type is
@@ -2806,7 +2841,12 @@ class OpaqueTypeDecl final :
   /// This maps types in the interface generic signature to the outer generic
   /// signature of the original declaration.
   Optional<SubstitutionMap> UnderlyingTypeSubstitutions;
-  
+
+  /// A set of substitutions which are used based on the availability
+  /// checks performed at runtime. This set of only populated if there
+  /// is no single unique underlying type for this opaque type declaration.
+  ConditionalAlternatives *ConditionallyAvailableTypes = nullptr;
+
   mutable Identifier OpaqueReturnTypeIdentifier;
 
   OpaqueTypeDecl(ValueDecl *NamingDecl, GenericParamList *GenericParams,
@@ -2891,7 +2931,15 @@ class OpaqueTypeDecl final :
     assert(!UnderlyingTypeSubstitutions.hasValue() && "resetting underlying type?!");
     UnderlyingTypeSubstitutions = subs;
   }
-  
+t
+  void setConditionallyAvailableSubstitutions(
+      ArrayRef<ConditionallyAvailableSubstitutions *> substitutions) {
+    assert(!ConditionallyAvailableTypes &&
+           "resetting conditional substitutions?!");
+    ConditionallyAvailableTypes =
+        ConditionalAlternatives::get(getASTContext(), substitutions);
+  }
+
   // Opaque type decls are currently always implicit
   SourceRange getSourceRange() const { return SourceRange(); }
 
@@ -2910,6 +2958,40 @@ class OpaqueTypeDecl final :
       return classof(D);
     return false;
   }
+
+  class ConditionallyAvailableSubstitutions final
+      : private llvm::TrailingObjects<ConditionallyAvailableSubstitutions,
+                                      VersionRange> {
+    friend TrailingObjects;
+
+    unsigned NumAvailabilityConditions;
+
+    SubstitutionMap Substitutions;
+
+    /// A type with limited availability described by the provided set
+    /// of availability conditions (with `and` relationship).
+    ConditionallyAvailableSubstitutions(
+        ArrayRef<VersionRange> availabilityContext,
+        SubstitutionMap substitutions)
+        : NumAvailabilityConditions(availabilityContext.size()),
+          Substitutions(substitutions) {
+      assert(!availabilityContext.empty());
+      std::uninitialized_copy(availabilityContext.begin(),
+                              availabilityContext.end(),
+                              getTrailingObjects<VersionRange>());
+    }
+
+  public:
+    ArrayRef<VersionRange> getAvailability() const {
+      return {getTrailingObjects<VersionRange>(), NumAvailabilityConditions};
+    }
+
+    SubstitutionMap getSubstitutions() const { return Substitutions; }
+
+    static ConditionallyAvailableSubstitutions *
+    get(ASTContext &ctx, ArrayRef<VersionRange> availabilityContext,
+        SubstitutionMap substitutions);
+  };
 };
 
 /// TypeAliasDecl - This is a declaration of a typealias, for example:

lib/AST/Decl.cpp

@@ -8173,6 +8173,26 @@ Identifier OpaqueTypeDecl::getOpaqueReturnTypeIdentifier() const {
   return OpaqueReturnTypeIdentifier;
 }
 
+OpaqueTypeDecl::ConditionalAlternatives *
+OpaqueTypeDecl::ConditionalAlternatives::get(
+    ASTContext &ctx,
+    ArrayRef<ConditionallyAvailableSubstitutions *> underlyingTypes) {
+  auto size = totalSizeToAlloc<ConditionallyAvailableSubstitutions *>(
+      underlyingTypes.size());
+  auto mem = ctx.Allocate(size, alignof(ConditionalAlternatives));
+  return new (mem) ConditionalAlternatives(underlyingTypes);
+}
+
+OpaqueTypeDecl::ConditionallyAvailableSubstitutions *
+OpaqueTypeDecl::ConditionallyAvailableSubstitutions::get(
+    ASTContext &ctx, ArrayRef<VersionRange> availabilityContext,
+    SubstitutionMap substitutions) {
+  auto size = totalSizeToAlloc<VersionRange>(availabilityContext.size());
+  auto mem = ctx.Allocate(size, alignof(ConditionallyAvailableSubstitutions));
+  return new (mem)
+      ConditionallyAvailableSubstitutions(availabilityContext, substitutions);
+}
+
 bool AbstractFunctionDecl::hasInlinableBodyText() const {
   switch (getBodyKind()) {
   case BodyKind::Deserialized: