Merge pull request #72206 from tshortli/conformance-complete-assertion

Author: tshortli

include/swift/AST/Decl.h

@@ -5074,6 +5074,35 @@ enum class KnownDerivableProtocolKind : uint8_t {
 
 using PrimaryAssociatedTypeName = std::pair<Identifier, SourceLoc>;
 
+/// A wrapper for a dictionary that maps Obj-C protocol requirement selectors to
+/// a list of function decls.
+class ObjCRequirementMap {
+public:
+  using FunctionList = TinyPtrVector<AbstractFunctionDecl *>;
+
+private:
+  using MethodKey = std::pair<ObjCSelector, char>;
+  llvm::SmallDenseMap<MethodKey, FunctionList, 4> storage;
+
+  static MethodKey getObjCMethodKey(AbstractFunctionDecl *func);
+
+public:
+  void addRequirement(AbstractFunctionDecl *requirement) {
+    storage[getObjCMethodKey(requirement)].push_back(requirement);
+  }
+
+  /// Retrieve the Objective-C requirements in this protocol that have the
+  /// given Objective-C method key.
+  FunctionList getRequirements(AbstractFunctionDecl *requirement) const {
+    auto key = getObjCMethodKey(requirement);
+    auto known = storage.find(key);
+    if (known == storage.end())
+      return {};
+
+    return known->second;
+  }
+};
+
 /// ProtocolDecl - A declaration of a protocol, for example:
 ///
 ///   protocol Drawable {
@@ -5303,6 +5332,10 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// i.e., for a protocol P, returns the kind if inverse constraint ~P exists.
   std::optional<InvertibleProtocolKind> getInvertibleProtocolKind() const;
 
+  /// Returns a dictionary that maps Obj-C protocol requirement selectors to a
+  /// list of function decls.
+  ObjCRequirementMap getObjCRequiremenMap() const;
+
 private:
   void computeKnownProtocolKind() const;
 

include/swift/AST/TypeCheckRequests.h

@@ -4828,6 +4828,23 @@ class LocalTypeDeclsRequest
   bool isCached() const { return true; }
 };
 
+class ObjCRequirementMapRequest
+    : public SimpleRequest<ObjCRequirementMapRequest,
+                           ObjCRequirementMap(const ProtocolDecl *proto),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  ObjCRequirementMap evaluate(Evaluator &evaluator,
+                              const ProtocolDecl *proto) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 #define SWIFT_TYPEID_ZONE TypeChecker
 #define SWIFT_TYPEID_HEADER "swift/AST/TypeCheckerTypeIDZone.def"
 #include "swift/Basic/DefineTypeIDZone.h"

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -559,3 +559,7 @@ SWIFT_REQUEST(TypeChecker, UniqueUnderlyingTypeSubstitutionsRequest,
 SWIFT_REQUEST(TypeChecker, LocalTypeDeclsRequest,
               ArrayRef<TypeDecl *>(SourceFile *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, ObjCRequirementMapRequest,
+              ObjCRequirementMap(const ProtocolDecl *proto),
+              Cached, NoLocationInfo)
+

lib/AST/Decl.cpp

@@ -6467,6 +6467,15 @@ ProtocolDecl::getInvertibleProtocolKind() const {
   return std::nullopt;
 }
 
+ObjCRequirementMap ProtocolDecl::getObjCRequiremenMap() const {
+  ObjCRequirementMap defaultMap;
+  if (!isObjC())
+    return defaultMap;
+
+  return evaluateOrDefault(getASTContext().evaluator,
+                           ObjCRequirementMapRequest{this}, defaultMap);
+}
+
 ArrayRef<ProtocolDecl *> ProtocolDecl::getInheritedProtocols() const {
   auto *mutThis = const_cast<ProtocolDecl *>(this);
   return evaluateOrDefault(getASTContext().evaluator,

lib/ClangImporter/ClangModuleDependencyScanner.cpp

@@ -455,7 +455,6 @@ bool ClangImporter::addHeaderDependencies(
     ModuleDependencyID moduleID,
     clang::tooling::dependencies::DependencyScanningTool &clangScanningTool,
     ModuleDependenciesCache &cache) {
-  auto &ctx = Impl.SwiftContext;
   auto optionalTargetModule = cache.findDependency(moduleID);
   assert(optionalTargetModule.has_value());
   auto targetModule = *(optionalTargetModule.value());

lib/Sema/AssociatedTypeInference.cpp

@@ -1172,23 +1172,6 @@ AssociatedTypeInference::AssociatedTypeInference(
     : ctx(ctx), conformance(conformance), proto(conformance->getProtocol()),
       dc(conformance->getDeclContext()), adoptee(conformance->getType()) {}
 
-static bool associatedTypesAreSameEquivalenceClass(AssociatedTypeDecl *a,
-                                                   AssociatedTypeDecl *b) {
-  if (a == b)
-    return true;
-
-  // TODO: Do a proper equivalence check here by looking for some relationship
-  // between a and b's protocols. In practice today, it's unlikely that
-  // two same-named associated types can currently be independent, since we
-  // don't have anything like `@implements(P.foo)` to rename witnesses (and
-  // we still fall back to name lookup for witnesses in more cases than we
-  // should).
-  if (a->getName() == b->getName())
-    return true;
-
-  return false;
-}
-
 namespace {
 
 /// Try to avoid situations where resolving the type of a witness calls back
@@ -1428,8 +1411,6 @@ static InferenceCandidateKind checkInferenceCandidate(
     NormalProtocolConformance *conformance,
     ValueDecl *witness,
     Type selfTy) {
-  auto &ctx = selfTy->getASTContext();
-
   // The unbound form of `Self.A`.
   auto selfAssocTy = DependentMemberType::get(selfTy, result->first->getName());
   auto genericSig = witness->getInnermostDeclContext()
@@ -1855,16 +1836,6 @@ AssociatedTypeInference::inferTypeWitnessesViaValueWitnesses(
   return result;
 }
 
-/// Map error types back to their original types.
-static Type mapErrorTypeToOriginal(Type type) {
-  if (auto errorType = type->getAs<ErrorType>()) {
-    if (auto originalType = errorType->getOriginalType())
-      return originalType.transform(mapErrorTypeToOriginal);
-  }
-
-  return type;
-}
-
 /// Desugar protocol type aliases, since they can cause request cycles in
 /// type resolution if printed in a module interface and parsed back in.
 static Type getWithoutProtocolTypeAliases(Type type) {
@@ -1937,8 +1908,6 @@ static Type getWitnessTypeForMatching(NormalProtocolConformance *conformance,
                       LookUpConformanceInModule(module));
   }
 
-  auto &ctx = conformance->getDeclContext()->getASTContext();
-
   auto proto = conformance->getProtocol();
   auto selfTy = proto->getSelfInterfaceType();
 
@@ -2906,8 +2875,6 @@ AssociatedTypeDecl *AssociatedTypeInference::inferAbstractTypeWitnesses(
   // not resolve otherwise.
   llvm::SmallVector<AbstractTypeWitness, 2> abstractTypeWitnesses;
 
-  auto selfTypeInContext = dc->getSelfTypeInContext();
-
   TypeWitnessSystem system(unresolvedAssocTypes);
   collectAbstractTypeWitnesses(system, unresolvedAssocTypes);
 

lib/Sema/CSDiagnostics.cpp

@@ -8202,7 +8202,6 @@ bool UnableToInferClosureReturnType::diagnoseAsError() {
 
 bool UnableToInferGenericPackElementType::diagnoseAsError() {
   auto *locator = getLocator();
-  auto path = locator->getPath();
 
   auto packElementElt = locator->getLastElementAs<LocatorPathElt::PackElement>();
   assert(packElementElt && "Expected path to end with a pack element locator");