GSB: Simplify ResolvedType implementation

We don't need to store the EquivalenceClass anymore.

Author: slavapestov

include/swift/AST/GenericSignatureBuilder.h

@@ -743,12 +743,6 @@ class GenericSignatureBuilder {
                             TypeArrayView<GenericTypeParamType> genericParams,
                             EquivalenceClass *equivClass);
 
-  /// Realize a potential archetype for the given type.
-  ///
-  /// The resolved archetype will be written back into the unresolved type,
-  /// to make the next resolution more efficient.
-  PotentialArchetype *realizePotentialArchetype(UnresolvedType &type);
-
 public:
   /// Try to resolve the equivalence class of the given type.
   ///

lib/AST/GenericSignatureBuilder.cpp

@@ -2380,20 +2380,9 @@ const RequirementSource *GenericSignatureBuilder::resolveSuperConformance(
   return superclassSource;
 }
 
-/// Realize a potential archetype for this type parameter.
-PotentialArchetype *ResolvedType::realizePotentialArchetype(
-                                           GenericSignatureBuilder &builder) {
-  // Realize and cache the potential archetype.
-  return builder.realizePotentialArchetype(type);
-}
-
 Type ResolvedType::getDependentType(GenericSignatureBuilder &builder) const {
-  // Already-resolved potential archetype.
-  if (auto pa = type.dyn_cast<PotentialArchetype *>())
-    return pa->getDependentType(builder.getGenericParams());
-
-  Type result = type.get<Type>();
-  return result->isTypeParameter() ? result : Type();
+  return storage.get<PotentialArchetype *>()
+      ->getDependentType(builder.getGenericParams());
 }
 
 auto PotentialArchetype::getOrCreateEquivalenceClass(
@@ -3550,20 +3539,6 @@ static Type resolveDependentMemberTypes(
   });
 }
 
-PotentialArchetype *GenericSignatureBuilder::realizePotentialArchetype(
-                                                     UnresolvedType &type) {
-  if (auto pa = type.dyn_cast<PotentialArchetype *>())
-    return pa;
-
-  auto pa = maybeResolveEquivalenceClass(type.get<Type>(),
-                                         ArchetypeResolutionKind::WellFormed,
-                                         /*wantExactPotentialArchetype=*/true)
-    .getPotentialArchetypeIfKnown();
-  if (pa) type = pa;
-
-  return pa;
-}
-
 static Type getStructuralType(TypeDecl *typeDecl, bool keepSugar) {
   if (auto typealias = dyn_cast<TypeAliasDecl>(typeDecl)) {
     if (typealias->getUnderlyingTypeRepr() != nullptr) {
@@ -4549,8 +4524,7 @@ GenericSignatureBuilder::addSameTypeRequirementBetweenTypeParameters(
       if (equivClass2) {
         equivClass = equivClass2;
       } else {
-        auto pa1 = type1.realizePotentialArchetype(*this);
-        equivClass = pa1->getOrCreateEquivalenceClass(*this);
+        equivClass = type1.getEquivalenceClass(*this);
       }
     }
 
@@ -4562,8 +4536,8 @@ GenericSignatureBuilder::addSameTypeRequirementBetweenTypeParameters(
 
   // Both sides are type parameters; equate them.
   // FIXME: Realizes potential archetypes far too early.
-  auto OrigT1 = type1.realizePotentialArchetype(*this);
-  auto OrigT2 = type2.realizePotentialArchetype(*this);
+  auto OrigT1 = type1.getPotentialArchetypeIfKnown();
+  auto OrigT2 = type2.getPotentialArchetypeIfKnown();
 
   // Operate on the representatives
   auto T1 = OrigT1->getRepresentative();

lib/AST/GenericSignatureBuilderImpl.h

@@ -13,24 +13,20 @@
 namespace swift {
 
 class GenericSignatureBuilder::ResolvedType {
-  llvm::PointerUnion<PotentialArchetype *, Type> type;
-  EquivalenceClass *equivClass;
+  llvm::PointerUnion<PotentialArchetype *, Type, EquivalenceClass *> storage;
 
   /// For a type that could not be resolved further unless the given
   /// equivalence class changes.
-  ResolvedType(EquivalenceClass *equivClass)
-    : type(), equivClass(equivClass) { }
+  ResolvedType(EquivalenceClass *equivClass) : storage(equivClass) { }
 
-  /// A concrete resolved type .
-  ResolvedType(Type type) : type(type), equivClass(nullptr) {
+  /// A concrete resolved type.
+  ResolvedType(Type type) : storage(type) {
     assert(!type->isTypeParameter());
   }
 
 public:
   /// A specific resolved potential archetype.
-  ResolvedType(PotentialArchetype *pa)
-    : type(pa), equivClass(nullptr) { }
-
+  ResolvedType(PotentialArchetype *pa) : storage(pa) { }
 
   /// Return an unresolved result, which could be resolved when we
   /// learn more information about the given equivalence class.
@@ -44,7 +40,9 @@ class GenericSignatureBuilder::ResolvedType {
   }
 
   /// Determine whether this result was resolved.
-  explicit operator bool() const { return !type.isNull(); }
+  explicit operator bool() const {
+    return storage.is<PotentialArchetype *>() || storage.is<Type>();
+  }
 
   /// Retrieve the dependent type.
   Type getDependentType(GenericSignatureBuilder &builder) const;
@@ -53,51 +51,38 @@ class GenericSignatureBuilder::ResolvedType {
   /// a concrete type.
   Type getAsConcreteType() const {
     assert(*this && "Doesn't contain any result");
-    if (equivClass) return Type();
-    return type.dyn_cast<Type>();
+    return storage.dyn_cast<Type>();
   }
 
-  /// Realize a potential archetype for this type parameter.
-  PotentialArchetype *realizePotentialArchetype(
-                                            GenericSignatureBuilder &builder);
-
   /// Retrieve the potential archetype, if already known.
   PotentialArchetype *getPotentialArchetypeIfKnown() const {
-    return type.dyn_cast<PotentialArchetype *>();
+    return storage.dyn_cast<PotentialArchetype *>();
   }
 
   /// Retrieve the equivalence class into which a resolved type refers.
   EquivalenceClass *getEquivalenceClass(
                      GenericSignatureBuilder &builder) const {
-    assert(*this && "Only for resolved types");
-    if (equivClass) return equivClass;
-
-    // Create the equivalence class now.
-    return type.get<PotentialArchetype *>()
+    return storage.get<PotentialArchetype *>()
              ->getOrCreateEquivalenceClass(builder);
   }
 
   /// Retrieve the equivalence class into which a resolved type refers.
   EquivalenceClass *getEquivalenceClassIfPresent() const {
-    assert(*this && "Only for resolved types");
-    if (equivClass) return equivClass;
-
-    // Create the equivalence class now.
-    return type.get<PotentialArchetype *>()->getEquivalenceClassIfPresent();
+    return storage.get<PotentialArchetype *>()
+            ->getEquivalenceClassIfPresent();
   }
 
   /// Retrieve the unresolved result.
   EquivalenceClass *getUnresolvedEquivClass() const {
-    assert(!*this);
-    return equivClass;
+    return storage.dyn_cast<EquivalenceClass *>();
   }
 
   /// Return an unresolved type.
-  ///
-  /// This loses equivalence-class information that could be useful, which
-  /// is unfortunate.
   UnresolvedType getUnresolvedType() const {
-    return type;
+    assert(!storage.is<EquivalenceClass *>());
+    if (storage.is<PotentialArchetype *>())
+      return storage.get<PotentialArchetype *>();
+    return storage.get<Type>();
   }
 };