AssociatedTypeInference: Delete old code for computing abstract type witnesses

Author: AnthonyLatsis

lib/Sema/TypeCheckProtocol.h

@@ -100,61 +100,6 @@ CheckTypeWitnessResult checkTypeWitness(Type type,
                                         const NormalProtocolConformance *Conf,
                                         SubstOptions options = None);
 
-/// Describes the means of inferring an abstract type witness.
-enum class AbstractTypeWitnessKind : uint8_t {
-  /// The type witness was inferred via a same-type-to-concrete constraint
-  /// in a protocol requirement signature.
-  Fixed,
-
-  /// The type witness was inferred via a defaulted associated type.
-  Default,
-
-  /// The type witness was inferred to a generic parameter of the
-  /// conforming type.
-  GenericParam,
-};
-
-/// A type witness inferred without the aid of a specific potential
-/// value witness.
-class AbstractTypeWitness {
-  AbstractTypeWitnessKind Kind;
-  AssociatedTypeDecl *AssocType;
-  Type TheType;
-
-  /// When this is a default type witness, the declaration responsible for it.
-  /// May not necessarilly match \c AssocType.
-  AssociatedTypeDecl *DefaultedAssocType;
-
-  AbstractTypeWitness(AbstractTypeWitnessKind Kind,
-                      AssociatedTypeDecl *AssocType, Type TheType,
-                      AssociatedTypeDecl *DefaultedAssocType)
-      : Kind(Kind), AssocType(AssocType), TheType(TheType),
-        DefaultedAssocType(DefaultedAssocType) {
-    assert(AssocType && TheType);
-  }
-
-public:
-  static AbstractTypeWitness forFixed(AssociatedTypeDecl *assocType, Type type);
-
-  static AbstractTypeWitness forDefault(AssociatedTypeDecl *assocType,
-                                        Type type,
-                                        AssociatedTypeDecl *defaultedAssocType);
-
-  static AbstractTypeWitness forGenericParam(AssociatedTypeDecl *assocType,
-                                             Type type);
-
-public:
-  AbstractTypeWitnessKind getKind() const { return Kind; }
-
-  AssociatedTypeDecl *getAssocType() const { return AssocType; }
-
-  Type getType() const { return TheType; }
-
-  AssociatedTypeDecl *getDefaultedAssocType() const {
-    return DefaultedAssocType;
-  }
-};
-
 /// The set of associated types that have been inferred by matching
 /// the given value witness to its corresponding requirement.
 struct InferredAssociatedTypesByWitness {
@@ -1134,24 +1079,16 @@ class AssociatedTypeInference {
     ConformanceChecker &checker,
     const llvm::SetVector<AssociatedTypeDecl *> &assocTypes);
 
-  /// Compute a "fixed" type witness for an associated type, e.g.,
-  /// if the refined protocol requires it to be equivalent to some other type.
-  Type computeFixedTypeWitness(AssociatedTypeDecl *assocType);
-
   /// Compute the default type witness from an associated type default,
   /// if there is one.
-  Optional<AbstractTypeWitness>
+  Optional<std::pair<AssociatedTypeDecl *, Type>>
   computeDefaultTypeWitness(AssociatedTypeDecl *assocType) const;
 
   /// Compute the "derived" type witness for an associated type that is
   /// known to the compiler.
   std::pair<Type, TypeDecl *>
   computeDerivedTypeWitness(AssociatedTypeDecl *assocType);
 
-  /// Compute a type witness without using a specific potential witness.
-  Optional<AbstractTypeWitness>
-  computeAbstractTypeWitness(AssociatedTypeDecl *assocType);
-
   /// Collect abstract type witnesses and feed them to the given system.
   void collectAbstractTypeWitnesses(
       TypeWitnessSystem &system,

lib/Sema/TypeCheckProtocolInference.cpp

@@ -44,25 +44,6 @@ STATISTIC(NumDuplicateSolutionStates,
 
 using namespace swift;
 
-AbstractTypeWitness AbstractTypeWitness::forFixed(AssociatedTypeDecl *assocType,
-                                                  Type type) {
-  return AbstractTypeWitness(AbstractTypeWitnessKind::Fixed, assocType, type,
-                             nullptr);
-}
-
-AbstractTypeWitness
-AbstractTypeWitness::forDefault(AssociatedTypeDecl *assocType, Type type,
-                                AssociatedTypeDecl *defaultedAssocType) {
-  return AbstractTypeWitness(AbstractTypeWitnessKind::Default, assocType, type,
-                             defaultedAssocType);
-}
-
-AbstractTypeWitness
-AbstractTypeWitness::forGenericParam(AssociatedTypeDecl *assocType, Type type) {
-  return AbstractTypeWitness(AbstractTypeWitnessKind::GenericParam, assocType,
-                             type, nullptr);
-}
-
 void InferredAssociatedTypesByWitness::dump() const {
   dump(llvm::errs(), 0);
 }
@@ -817,56 +798,7 @@ AssociatedTypeDecl *AssociatedTypeInference::findDefaultedAssociatedType(
   return results.size() == 1 ? results.front() : nullptr;
 }
 
-Type AssociatedTypeInference::computeFixedTypeWitness(
-                                            AssociatedTypeDecl *assocType) {
-  Type resultType;
-
-  // Look at all of the inherited protocols to determine whether they
-  // require a fixed type for this associated type.
-  for (auto conformedProto : adoptee->getAnyNominal()->getAllProtocols()) {
-    if (conformedProto != assocType->getProtocol() &&
-        !conformedProto->inheritsFrom(assocType->getProtocol()))
-      continue;
-
-    auto sig = conformedProto->getGenericSignature();
-
-    // FIXME: The RequirementMachine will assert on re-entrant construction.
-    // We should find a more principled way of breaking this cycle.
-    if (ctx.isRecursivelyConstructingRequirementMachine(sig.getCanonicalSignature()) ||
-        ctx.isRecursivelyConstructingRequirementMachine(conformedProto) ||
-        conformedProto->isComputingRequirementSignature())
-      continue;
-
-    auto selfTy = conformedProto->getSelfInterfaceType();
-    if (!sig->requiresProtocol(selfTy, assocType->getProtocol()))
-      continue;
-
-    auto structuralTy = DependentMemberType::get(selfTy, assocType->getName());
-    const auto ty = sig.getCanonicalTypeInContext(structuralTy);
-
-    // A dependent member type with an identical base and name indicates that
-    // the protocol does not same-type constrain it in any way; move on to
-    // the next protocol.
-    if (auto *const memberTy = ty->getAs<DependentMemberType>()) {
-      if (memberTy->getBase()->isEqual(selfTy) &&
-          memberTy->getName() == assocType->getName())
-        continue;
-    }
-
-    if (!resultType) {
-      resultType = ty;
-      continue;
-    }
-
-    // FIXME: Bailing out on ambiguity.
-    if (!resultType->isEqual(ty))
-      return Type();
-  }
-
-  return resultType;
-}
-
-Optional<AbstractTypeWitness>
+Optional<std::pair<AssociatedTypeDecl *, Type>>
 AssociatedTypeInference::computeDefaultTypeWitness(
     AssociatedTypeDecl *assocType) const {
   // Go find a default definition.
@@ -882,8 +814,7 @@ AssociatedTypeInference::computeDefaultTypeWitness(
   if (defaultType->hasError())
     return None;
 
-  return AbstractTypeWitness::forDefault(assocType, defaultType,
-                                         defaultedAssocType);
+  return std::make_pair(defaultedAssocType, defaultType);
 }
 
 std::pair<Type, TypeDecl *>
@@ -914,29 +845,6 @@ AssociatedTypeInference::computeDerivedTypeWitness(
   return result;
 }
 
-Optional<AbstractTypeWitness>
-AssociatedTypeInference::computeAbstractTypeWitness(
-    AssociatedTypeDecl *assocType) {
-  // We don't have a type witness for this associated type, so go
-  // looking for more options.
-  if (Type concreteType = computeFixedTypeWitness(assocType))
-    return AbstractTypeWitness::forFixed(assocType, concreteType);
-
-  // If we can form a default type, do so.
-  if (const auto &typeWitness = computeDefaultTypeWitness(assocType))
-    return typeWitness;
-
-  // If there is a generic parameter of the named type, use that.
-  if (auto genericSig = dc->getGenericSignatureOfContext()) {
-    for (auto gp : genericSig.getInnermostGenericParams()) {
-      if (gp->getName() == assocType->getName())
-        return AbstractTypeWitness::forGenericParam(assocType, gp);
-    }
-  }
-
-  return None;
-}
-
 void AssociatedTypeInference::collectAbstractTypeWitnesses(
     TypeWitnessSystem &system,
     ArrayRef<AssociatedTypeDecl *> unresolvedAssocTypes) const {
@@ -970,9 +878,8 @@ void AssociatedTypeInference::collectAbstractTypeWitnesses(
     }
 
     // If we find a default type definition, feed it to the system.
-    if (const auto &typeWitness = computeDefaultTypeWitness(assocType)) {
-      system.addDefaultTypeWitness(typeWitness->getType(),
-                                   typeWitness->getDefaultedAssocType());
+    if (const auto declAndType = computeDefaultTypeWitness(assocType)) {
+      system.addDefaultTypeWitness(declAndType->second, declAndType->first);
     } else {
       // As a last resort, look for a generic parameter that matches the name
       // of the associated type.