GSB: Simplify representation of FloatingRequirementSource

Author: slavapestov

include/swift/AST/GenericSignatureBuilder.h

@@ -1129,7 +1129,7 @@ class GenericSignatureBuilder::RequirementSource final
   /// parameter or result type of a generic function.
   static const RequirementSource *forInferred(GenericSignatureBuilder &builder,
                                               Type rootType,
-                                              const TypeRepr *typeRepr);
+                                              WrittenRequirementLoc writtenLoc);
 
   /// Retrieve a requirement source representing the requirement signature
   /// computation for a protocol.
@@ -1352,70 +1352,71 @@ class GenericSignatureBuilder::RequirementSource final
 /// The root will be supplied as soon as the appropriate dependent type is
 /// resolved.
 class GenericSignatureBuilder::FloatingRequirementSource {
-  enum Kind {
+  enum Kind : uint8_t {
     /// A fully-resolved requirement source, which does not need a root.
     Resolved,
-    /// An explicit requirement source lacking a root.
+    /// An explicit requirement in a generic signature.
     Explicit,
-    /// An inferred requirement source lacking a root.
+    /// A requirement inferred from a concrete type application in a
+    /// generic signature.
     Inferred,
-    /// A requirement source augmented by an abstract protocol requirement
-    AbstractProtocol,
+    /// An explicit requirement written inside a protocol.
+    ProtocolRequirement,
+    /// A requirement inferred from a concrete type application inside a
+    /// protocol.
+    InferredProtocolRequirement,
     /// A requirement source for a nested-type-name match introduced by
     /// the given source.
     NestedTypeNameMatch,
   } kind;
 
-  using Storage =
-    llvm::PointerUnion<const RequirementSource *, const TypeRepr *,
-                       const RequirementRepr *>;
-
-  Storage storage;
+  const RequirementSource *source;
+  WrittenRequirementLoc loc;
 
   // Additional storage for an abstract protocol requirement.
   union {
-    struct {
-      ProtocolDecl *protocol = nullptr;
-      WrittenRequirementLoc written;
-      bool inferred = false;
-    } protocolReq;
-
+    ProtocolDecl *protocol = nullptr;
     Identifier nestedName;
   };
 
-  FloatingRequirementSource(Kind kind, Storage storage)
-    : kind(kind), storage(storage) { }
+  FloatingRequirementSource(Kind kind, const RequirementSource *source)
+    : kind(kind), source(source) { }
 
 public:
   /// Implicit conversion from a resolved requirement source.
   FloatingRequirementSource(const RequirementSource *source)
     : FloatingRequirementSource(Resolved, source) { }
 
   static FloatingRequirementSource forAbstract() {
-    return { Explicit, Storage() };
+    return { Explicit, nullptr };
   }
 
   static FloatingRequirementSource forExplicit(const TypeRepr *typeRepr) {
-    return { Explicit, typeRepr };
+    FloatingRequirementSource result{ Explicit, nullptr };
+    result.loc = typeRepr;
+    return result;
   }
 
   static FloatingRequirementSource forExplicit(
                                      const RequirementRepr *requirementRepr) {
-    return { Explicit, requirementRepr };
+    FloatingRequirementSource result{ Explicit, nullptr };
+    result.loc = requirementRepr;
+    return result;
   }
 
   static FloatingRequirementSource forInferred(const TypeRepr *typeRepr) {
-    return { Inferred, typeRepr };
+    FloatingRequirementSource result{ Inferred, nullptr };
+    result.loc = typeRepr;
+    return result;
   }
 
   static FloatingRequirementSource viaProtocolRequirement(
                                      const RequirementSource *base,
                                      ProtocolDecl *inProtocol,
                                      bool inferred) {
-    FloatingRequirementSource result{ AbstractProtocol, base };
-    result.protocolReq.protocol = inProtocol;
-    result.protocolReq.written = WrittenRequirementLoc();
-    result.protocolReq.inferred = inferred;
+    auto kind = (inferred ? InferredProtocolRequirement : ProtocolRequirement);
+    FloatingRequirementSource result{ kind, base };
+    result.protocol = inProtocol;
     return result;
   }
 
@@ -1424,16 +1425,16 @@ class GenericSignatureBuilder::FloatingRequirementSource {
                                      ProtocolDecl *inProtocol,
                                      WrittenRequirementLoc written,
                                      bool inferred) {
-    FloatingRequirementSource result{ AbstractProtocol, base };
-    result.protocolReq.protocol = inProtocol;
-    result.protocolReq.written = written;
-    result.protocolReq.inferred = inferred;
+    auto kind = (inferred ? InferredProtocolRequirement : ProtocolRequirement);
+    FloatingRequirementSource result{ kind, base };
+    result.protocol = inProtocol;
+    result.loc = written;
     return result;
   }
 
   static FloatingRequirementSource forNestedTypeNameMatch(
                                      Identifier nestedName) {
-    FloatingRequirementSource result{ NestedTypeNameMatch, Storage() };
+    FloatingRequirementSource result{ NestedTypeNameMatch, nullptr };
     result.nestedName = nestedName;
     return result;
   };

lib/AST/GenericSignatureBuilder.cpp

@@ -1158,8 +1158,7 @@ const RequirementSource *RequirementSource::forExplicit(
 const RequirementSource *RequirementSource::forInferred(
                                               GenericSignatureBuilder &builder,
                                               Type rootType,
-                                              const TypeRepr *typeRepr) {
-  WrittenRequirementLoc writtenLoc = typeRepr;
+                                              WrittenRequirementLoc writtenLoc) {
   REQUIREMENT_SOURCE_FACTORY_BODY(
       (nodeID, Inferred, nullptr, rootType.getPointer(),
        writtenLoc.getOpaqueValue(), nullptr),
@@ -1646,40 +1645,34 @@ const RequirementSource *FloatingRequirementSource::getSource(
                                               ResolvedType type) const {
   switch (kind) {
   case Resolved:
-    return storage.get<const RequirementSource *>();
+    return source;
 
   case Explicit: {
     auto depType = type.getDependentType(builder);
-
-    if (auto requirementRepr = storage.dyn_cast<const RequirementRepr *>())
-      return RequirementSource::forExplicit(builder, depType, requirementRepr);
-    if (auto typeRepr = storage.dyn_cast<const TypeRepr *>())
-      return RequirementSource::forExplicit(builder, depType, typeRepr);
-    return RequirementSource::forAbstract(builder, depType);
+    return RequirementSource::forExplicit(builder, depType, loc);
   }
 
   case Inferred: {
     auto depType = type.getDependentType(builder);
-    return RequirementSource::forInferred(builder, depType,
-                                          storage.get<const TypeRepr *>());
+    return RequirementSource::forInferred(builder, depType, loc);
   }
 
-  case AbstractProtocol: {
+  case ProtocolRequirement:
+  case InferredProtocolRequirement: {
     auto depType = type.getDependentType();
 
     // Derive the dependent type on which this requirement was written. It is
     // the path from the requirement source on which this requirement is based
     // to the potential archetype on which the requirement is being placed.
-    auto baseSource = storage.get<const RequirementSource *>();
-    auto baseSourceType = baseSource->getAffectedType();
+    auto baseSourceType = source->getAffectedType();
 
     auto dependentType =
-      formProtocolRelativeType(protocolReq.protocol, baseSourceType, depType);
+      formProtocolRelativeType(protocol, baseSourceType, depType);
 
-    return storage.get<const RequirementSource *>()
-      ->viaProtocolRequirement(builder, dependentType,
-                               protocolReq.protocol, protocolReq.inferred,
-                               protocolReq.written);
+    return source
+      ->viaProtocolRequirement(builder, dependentType, protocol,
+                               kind == InferredProtocolRequirement,
+                               loc);
   }
 
   case NestedTypeNameMatch: {
@@ -1688,29 +1681,20 @@ const RequirementSource *FloatingRequirementSource::getSource(
   }
   }
 
-  llvm_unreachable("Unhandled FloatingPointRequirementSourceKind in switch.");
+  llvm_unreachable("unhandled kind");
 }
 
 SourceLoc FloatingRequirementSource::getLoc() const {
-  // For an explicit abstract protocol source, we can get a more accurate source
-  // location from the written protocol requirement.
-  if (kind == Kind::AbstractProtocol && isExplicit()) {
-    auto written = protocolReq.written;
-    if (auto typeRepr = written.dyn_cast<const TypeRepr *>())
+  if (kind == Inferred || isExplicit()) {
+    if (auto typeRepr = loc.dyn_cast<const TypeRepr *>())
       return typeRepr->getLoc();
-    if (auto requirementRepr = written.dyn_cast<const RequirementRepr *>())
+    if (auto requirementRepr = loc.dyn_cast<const RequirementRepr *>())
       return requirementRepr->getSeparatorLoc();
   }
 
-  if (auto source = storage.dyn_cast<const RequirementSource *>())
+  if (source)
     return source->getLoc();
 
-  if (auto typeRepr = storage.dyn_cast<const TypeRepr *>())
-    return typeRepr->getLoc();
-
-  if (auto requirementRepr = storage.dyn_cast<const RequirementRepr *>())
-    return requirementRepr->getSeparatorLoc();
-
   return SourceLoc();
 }
 
@@ -1721,8 +1705,9 @@ bool FloatingRequirementSource::isDerived() const {
   case NestedTypeNameMatch:
     return false;
 
-  case AbstractProtocol:
-    switch (storage.get<const RequirementSource *>()->kind) {
+  case ProtocolRequirement:
+  case InferredProtocolRequirement:
+    switch (source->kind) {
     case RequirementSource::RequirementSignatureSelf:
       return false;
 
@@ -1740,7 +1725,7 @@ bool FloatingRequirementSource::isDerived() const {
     }
 
   case Resolved:
-    return storage.get<const RequirementSource *>()->isDerivedRequirement();
+    return source->isDerivedRequirement();
   }
   llvm_unreachable("unhandled kind");
 }
@@ -1754,14 +1739,14 @@ bool FloatingRequirementSource::isExplicit() const {
   case NestedTypeNameMatch:
     return false;
 
-  case AbstractProtocol:
+  case ProtocolRequirement:
     // Requirements implied by other protocol conformance requirements are
     // implicit, except when computing a requirement signature, where
     // non-inferred ones are explicit, to allow flagging of redundant
     // requirements.
-    switch (storage.get<const RequirementSource *>()->kind) {
+    switch (source->kind) {
     case RequirementSource::RequirementSignatureSelf:
-      return !protocolReq.inferred;
+      return true;
 
     case RequirementSource::Concrete:
     case RequirementSource::Explicit:
@@ -1776,14 +1761,16 @@ bool FloatingRequirementSource::isExplicit() const {
       return false;
     }
 
+  case InferredProtocolRequirement:
+    return false;
+
   case Resolved:
-    switch (storage.get<const RequirementSource *>()->kind) {
+    switch (source->kind) {
     case RequirementSource::Explicit:
       return true;
 
     case RequirementSource::ProtocolRequirement:
-      return storage.get<const RequirementSource *>()->parent->kind
-        == RequirementSource::RequirementSignatureSelf;
+      return source->parent->kind == RequirementSource::RequirementSignatureSelf;
 
     case RequirementSource::Inferred:
     case RequirementSource::InferredProtocolRequirement:
@@ -1812,9 +1799,9 @@ FloatingRequirementSource FloatingRequirementSource::asInferred(
   case NestedTypeNameMatch:
     return *this;
 
-  case AbstractProtocol:
-    return viaProtocolRequirement(storage.get<const RequirementSource *>(),
-                                  protocolReq.protocol, typeRepr,
+  case ProtocolRequirement:
+  case InferredProtocolRequirement:
+    return viaProtocolRequirement(source, protocol, typeRepr,
                                   /*inferred=*/true);
   }
   llvm_unreachable("unhandled kind");
@@ -1823,8 +1810,8 @@ FloatingRequirementSource FloatingRequirementSource::asInferred(
 bool FloatingRequirementSource::isRecursive(
                                     GenericSignatureBuilder &builder) const {
   llvm::SmallSet<std::pair<CanType, ProtocolDecl *>, 32> visitedAssocReqs;
-  for (auto storedSource = storage.dyn_cast<const RequirementSource *>();
-       storedSource; storedSource = storedSource->parent) {
+  for (auto storedSource = source; storedSource;
+       storedSource = storedSource->parent) {
     // FIXME: isRecursive() is completely misnamed
     if (storedSource->kind == RequirementSource::EquivalentType)
       return true;