AST: Split off ProtocolConformanceRef.cpp from ProtocolConformance.cpp

Author: slavapestov

lib/AST/CMakeLists.txt

@@ -74,6 +74,7 @@ add_swift_host_library(swiftAST STATIC
   PlatformKind.cpp
   PrettyStackTrace.cpp
   ProtocolConformance.cpp
+  ProtocolConformanceRef.cpp
   RawComment.cpp
   RequirementEnvironment.cpp
   RequirementMachine/ConcreteContraction.cpp

lib/AST/ProtocolConformance.cpp

@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file implements the protocol conformance data structures.
+// This file implements the ProtocolConformance class hierarchy.
 //
 //===----------------------------------------------------------------------===//
 
@@ -25,13 +25,9 @@
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/TypeCheckRequests.h"
-#include "swift/AST/TypeWalker.h"
 #include "swift/AST/Types.h"
-#include "swift/AST/TypeCheckRequests.h"
 #include "swift/Basic/Statistic.h"
-#include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/Statistic.h"
-#include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/SaveAndRestore.h"
 
@@ -79,128 +75,6 @@ void Witness::dump(llvm::raw_ostream &out) const {
   }
 }
 
-ProtocolConformanceRef::ProtocolConformanceRef(ProtocolDecl *protocol,
-                                               ProtocolConformance *conf) {
-  assert(protocol != nullptr &&
-         "cannot construct ProtocolConformanceRef with null protocol");
-  if (conf) {
-    assert(protocol == conf->getProtocol() && "protocol conformance mismatch");
-    Union = conf;
-  } else {
-    Union = protocol;
-  }
-}
-
-ProtocolDecl *ProtocolConformanceRef::getRequirement() const {
-  assert(!isInvalid());
-
-  if (isConcrete()) {
-    return getConcrete()->getProtocol();
-  } else {
-    return getAbstract();
-  }
-}
-
-ProtocolConformanceRef
-ProtocolConformanceRef::subst(Type origType,
-                              SubstitutionMap subMap,
-                              SubstOptions options) const {
-  return subst(origType,
-               QuerySubstitutionMap{subMap},
-               LookUpConformanceInSubstitutionMap(subMap),
-               options);
-}
-
-ProtocolConformanceRef
-ProtocolConformanceRef::subst(Type origType,
-                              TypeSubstitutionFn subs,
-                              LookupConformanceFn conformances,
-                              SubstOptions options) const {
-  if (isInvalid())
-    return *this;
-
-  // If we have a concrete conformance, we need to substitute the
-  // conformance to apply to the new type.
-  if (isConcrete())
-    return ProtocolConformanceRef(getConcrete()->subst(subs, conformances,
-                                                       options));
-  // If the type is an opaque archetype, the conformance will remain abstract,
-  // unless we're specifically substituting opaque types.
-  if (auto origArchetype = origType->getAs<ArchetypeType>()) {
-    if (!options.contains(SubstFlags::SubstituteOpaqueArchetypes)
-        && isa<OpaqueTypeArchetypeType>(origArchetype)) {
-      return *this;
-    }
-  }
-
-  // Otherwise, compute the substituted type.
-  auto substType = origType.subst(subs, conformances, options);
-
-  auto *proto = getRequirement();
-
-  // If the type is an existential, it must be self-conforming.
-  if (substType->isExistentialType()) {
-    auto optConformance =
-        proto->getModuleContext()->lookupExistentialConformance(substType,
-                                                                proto);
-    if (optConformance)
-      return optConformance;
-
-    return ProtocolConformanceRef::forInvalid();
-  }
-
-  // Check the conformance map.
-  return conformances(origType->getCanonicalType(), substType, proto);
-}
-
-ProtocolConformanceRef ProtocolConformanceRef::mapConformanceOutOfContext() const {
-  if (!isConcrete())
-    return *this;
-
-  auto *concrete = getConcrete()->subst(
-      [](SubstitutableType *type) -> Type {
-        if (auto *archetypeType = type->getAs<ArchetypeType>())
-          return archetypeType->getInterfaceType();
-        return type;
-      },
-      MakeAbstractConformanceForGenericType());
-  return ProtocolConformanceRef(concrete);
-}
-
-Type
-ProtocolConformanceRef::getTypeWitnessByName(Type type, Identifier name) const {
-  assert(!isInvalid());
-
-  // Find the named requirement.
-  ProtocolDecl *proto = getRequirement();
-  auto *assocType = proto->getAssociatedType(name);
-
-  // FIXME: Shouldn't this be a hard error?
-  if (!assocType)
-    return ErrorType::get(proto->getASTContext());
-
-  return assocType->getDeclaredInterfaceType().subst(
-    SubstitutionMap::getProtocolSubstitutions(proto, type, *this));
-}
-
-ConcreteDeclRef
-ProtocolConformanceRef::getWitnessByName(Type type, DeclName name) const {
-  // Find the named requirement.
-  auto *proto = getRequirement();
-  auto *requirement = proto->getSingleRequirement(name);
-  if (requirement == nullptr)
-    return ConcreteDeclRef();
-
-  // For a type with dependent conformance, just return the requirement from
-  // the protocol. There are no protocol conformance tables.
-  if (!isConcrete()) {
-    auto subs = SubstitutionMap::getProtocolSubstitutions(proto, type, *this);
-    return ConcreteDeclRef(requirement, subs);
-  }
-
-  return getConcrete()->getWitnessDeclRef(requirement);
-}
-
 #define CONFORMANCE_SUBCLASS_DISPATCH(Method, Args)                          \
 switch (getKind()) {                                                         \
   case ProtocolConformanceKind::Normal:                                      \
@@ -455,26 +329,6 @@ ArrayRef<Requirement> ProtocolConformance::getConditionalRequirements() const {
   CONFORMANCE_SUBCLASS_DISPATCH(getConditionalRequirements, ());
 }
 
-Optional<ArrayRef<Requirement>>
-ProtocolConformanceRef::getConditionalRequirementsIfAvailable() const {
-  if (isConcrete())
-    return getConcrete()->getConditionalRequirementsIfAvailable();
-  else
-    // An abstract conformance is never conditional: any conditionality in the
-    // concrete types that will eventually pass through this at runtime is
-    // completely pre-checked and packaged up.
-    return ArrayRef<Requirement>();
-}
-
-ArrayRef<Requirement>
-ProtocolConformanceRef::getConditionalRequirements() const {
-  if (isConcrete())
-    return getConcrete()->getConditionalRequirements();
-  else
-    // An abstract conformance is never conditional, as above.
-    return {};
-}
-
 Optional<ArrayRef<Requirement>>
 NormalProtocolConformance::getConditionalRequirementsIfAvailable() const {
   const auto &eval = getDeclContext()->getASTContext().evaluator;
@@ -682,54 +536,6 @@ Type ProtocolConformance::getAssociatedType(Type assocType) const {
   return ref.getAssociatedType(getType(), assocType);
 }
 
-Type ProtocolConformanceRef::getAssociatedType(Type conformingType,
-                                               Type assocType) const {
-  assert(!isConcrete() || getConcrete()->getType()->isEqual(conformingType));
-
-  auto type = assocType->getCanonicalType();
-  auto proto = getRequirement();
-
-  // Fast path for generic parameters.
-  if (isa<GenericTypeParamType>(type)) {
-    assert(type->isEqual(proto->getSelfInterfaceType()) &&
-           "type parameter in protocol was not Self");
-    return conformingType;
-  }
-
-  // Fast path for dependent member types on 'Self' of our associated types.
-  auto memberType = cast<DependentMemberType>(type);
-  if (memberType.getBase()->isEqual(proto->getSelfInterfaceType()) &&
-      memberType->getAssocType()->getProtocol() == proto &&
-      isConcrete())
-    return getConcrete()->getTypeWitness(memberType->getAssocType());
-
-  // General case: consult the substitution map.
-  auto substMap =
-    SubstitutionMap::getProtocolSubstitutions(proto, conformingType, *this);
-  return type.subst(substMap);
-}
-
-ProtocolConformanceRef
-ProtocolConformanceRef::getAssociatedConformance(Type conformingType,
-                                                 Type assocType,
-                                                 ProtocolDecl *protocol) const {
-  // If this is a concrete conformance, look up the associated conformance.
-  if (isConcrete()) {
-    auto conformance = getConcrete();
-    assert(conformance->getType()->isEqual(conformingType));
-    return conformance->getAssociatedConformance(assocType, protocol);
-  }
-
-  // Otherwise, apply the substitution {self -> conformingType}
-  // to the abstract conformance requirement laid upon the dependent type
-  // by the protocol.
-  auto subMap =
-    SubstitutionMap::getProtocolSubstitutions(getRequirement(),
-                                              conformingType, *this);
-  auto abstractConf = ProtocolConformanceRef(protocol);
-  return abstractConf.subst(assocType, subMap);
-}
-
 ProtocolConformanceRef
 ProtocolConformance::getAssociatedConformance(Type assocType,
                                                ProtocolDecl *protocol) const {
@@ -1669,20 +1475,6 @@ ProtocolConformance *ProtocolConformance::getCanonicalConformance() {
   llvm_unreachable("bad ProtocolConformanceKind");
 }
 
-/// Check of all types used by the conformance are canonical.
-bool ProtocolConformanceRef::isCanonical() const {
-  if (isAbstract() || isInvalid())
-    return true;
-  return getConcrete()->isCanonical();
-}
-
-ProtocolConformanceRef
-ProtocolConformanceRef::getCanonicalConformanceRef() const {
-  if (isAbstract() || isInvalid())
-    return *this;
-  return ProtocolConformanceRef(getConcrete()->getCanonicalConformance());
-}
-
 BuiltinProtocolConformance::BuiltinProtocolConformance(
     Type conformingType, ProtocolDecl *protocol,
     GenericSignature genericSig,
@@ -1742,76 +1534,3 @@ void swift::simple_display(llvm::raw_ostream &out,
 SourceLoc swift::extractNearestSourceLoc(const ProtocolConformance *conformance) {
   return extractNearestSourceLoc(conformance->getDeclContext());
 }
-
-void swift::simple_display(llvm::raw_ostream &out, ProtocolConformanceRef conformanceRef) {
-  if (conformanceRef.isAbstract()) {
-    simple_display(out, conformanceRef.getAbstract());
-  } else if (conformanceRef.isConcrete()) {
-    simple_display(out, conformanceRef.getConcrete());
-  }
-}
-
-SourceLoc swift::extractNearestSourceLoc(const ProtocolConformanceRef conformanceRef) {
-  if (conformanceRef.isAbstract()) {
-    return extractNearestSourceLoc(conformanceRef.getAbstract());
-  } else if (conformanceRef.isConcrete()) {
-    return extractNearestSourceLoc(conformanceRef.getConcrete());
-  }
-  return SourceLoc();
-}
-
-bool ProtocolConformanceRef::hasUnavailableConformance() const {
-  if (isInvalid())
-    return false;
-
-  // Abstract conformances are never unavailable.
-  if (!isConcrete())
-    return false;
-
-  // Check whether this conformance is on an unavailable extension.
-  auto concrete = getConcrete();
-  auto ext = dyn_cast<ExtensionDecl>(concrete->getDeclContext());
-  if (ext && AvailableAttr::isUnavailable(ext))
-    return true;
-
-  // Check the conformances in the substitution map.
-  auto module = concrete->getDeclContext()->getParentModule();
-  auto subMap = concrete->getSubstitutions(module);
-  for (auto subConformance : subMap.getConformances()) {
-    if (subConformance.hasUnavailableConformance())
-      return true;
-  }
-
-  return false;
-}
-
-bool ProtocolConformanceRef::hasMissingConformance(ModuleDecl *module) const {
-  return forEachMissingConformance(module,
-      [](BuiltinProtocolConformance *builtin) {
-        return true;
-      });
-}
-
-bool ProtocolConformanceRef::forEachMissingConformance(
-    ModuleDecl *module,
-    llvm::function_ref<bool(BuiltinProtocolConformance *missing)> fn) const {
-  if (!isConcrete())
-    return false;
-
-  // Is this a missing conformance?
-  ProtocolConformance *concreteConf = getConcrete();
-  RootProtocolConformance *rootConf = concreteConf->getRootConformance();
-  if (auto builtinConformance = dyn_cast<BuiltinProtocolConformance>(rootConf)){
-    if (builtinConformance->isMissing() && fn(builtinConformance))
-      return true;
-  }
-
-  // Check conformances that are part of this conformance.
-  auto subMap = concreteConf->getSubstitutions(module);
-  for (auto conformance : subMap.getConformances()) {
-    if (conformance.forEachMissingConformance(module, fn))
-      return true;
-  }
-
-  return false;
-}