[AST/Sema] NFC: Remove obsolete getMarking(...) and InvertibleAnnotationRequest

Author: xedin

include/swift/AST/InverseMarking.h

@@ -19,8 +19,6 @@
 
 namespace swift {
 
-class InvertibleAnnotationRequest;
-
 /// Describes the way an inverse and its corresponding positive contraint
 /// appears on a TypeDecl, i.e., the way it was marked.
 struct InverseMarking {
@@ -91,8 +89,6 @@ struct InverseMarking {
   Mark inverse;
   Mark positive;
 
-  // This friend initializes the marks.
-  friend InvertibleAnnotationRequest;
 public:
 
   // Creates an empty marking.

include/swift/AST/TypeCheckRequests.h

@@ -429,28 +429,6 @@ class IsFinalRequest :
   void cacheResult(bool value) const;
 };
 
-/// Determine the kind of invertible protocol markings for this declaration,
-/// for example, if a conformance to IP or ~IP was written on it in the
-/// inheritance clause and/or where clause.
-class InvertibleAnnotationRequest
-    : public SimpleRequest<InvertibleAnnotationRequest,
-                           InverseMarking(TypeDecl *, InvertibleProtocolKind),
-                           RequestFlags::Cached> {
-public:
-  using SimpleRequest::SimpleRequest;
-
-private:
-  friend SimpleRequest;
-
-  // Evaluation.
-  InverseMarking evaluate(Evaluator &evaluator,
-                          TypeDecl *decl, InvertibleProtocolKind ip) const;
-
-public:
-  // Caching.
-  bool isCached() const { return true; }
-};
-
 /// Determine whether the given declaration is 'dynamic''.
 class IsDynamicRequest :
     public SimpleRequest<IsDynamicRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -217,9 +217,6 @@ SWIFT_REQUEST(TypeChecker, IsDynamicRequest, bool(ValueDecl *),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsFinalRequest, bool(ValueDecl *), SeparatelyCached,
               NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, InvertibleAnnotationRequest,
-              InverseMarking(TypeDecl *, InvertibleProtocolKind),
-              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsGetterMutatingRequest, bool(AbstractStorageDecl *),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsImplicitlyUnwrappedOptionalRequest,

lib/AST/Decl.cpp

@@ -4909,14 +4909,6 @@ TypeDecl::hasInverseMarking(InvertibleProtocolKind target) const {
   return InverseMarking::Mark(InverseMarking::Kind::None);
 }
 
-InverseMarking TypeDecl::getMarking(InvertibleProtocolKind ip) const {
-  return evaluateOrDefault(
-      getASTContext().evaluator,
-      InvertibleAnnotationRequest{const_cast<TypeDecl *>(this), ip},
-      InverseMarking::forInverse(InverseMarking::Kind::None)
-  );
-}
-
 static TypeDecl::CanBeInvertible::Result
 conformanceExists(TypeDecl const *decl, InvertibleProtocolKind ip) {
   auto *proto = decl->getASTContext().getProtocol(getKnownProtocolKind(ip));

lib/Sema/TypeCheckDecl.cpp

@@ -911,176 +911,6 @@ IsFinalRequest::evaluate(Evaluator &evaluator, ValueDecl *decl) const {
   return explicitFinalAttr;
 }
 
-InverseMarking
-InvertibleAnnotationRequest::evaluate(Evaluator &evaluator,
-                                       TypeDecl *decl,
-                                       InvertibleProtocolKind ip) const {
-  assert(!isa<ProtocolDecl>(decl));
-
-  auto &ctx = decl->getASTContext();
-  const auto TARGET = ip;
-  using Kind = InverseMarking::Kind;
-  using Mark = InverseMarking::Mark;
-
-  switch (TARGET) {
-  case InvertibleProtocolKind::Copyable:
-    // Handle the legacy '@_moveOnly' for types they can validly appear.
-    // TypeCheckAttr handles the illegal situations for us.
-    if (auto attr = decl->getAttrs().getAttribute<MoveOnlyAttr>())
-      if (isa<StructDecl, EnumDecl, ClassDecl>(decl))
-        return InverseMarking::forInverse(Kind::LegacyExplicit,
-                                          attr->getLocation());
-    break;
-
-  case InvertibleProtocolKind::Escapable:
-    // Handle the legacy '@_nonEscapable' attribute
-    if (auto attr = decl->getAttrs().getAttribute<NonEscapableAttr>()) {
-      assert((isa<ClassDecl, StructDecl, EnumDecl>(decl)));
-      return InverseMarking::forInverse(Kind::LegacyExplicit,
-                                        attr->getLocation());
-    }
-    break;
-  }
-
-  // Legacy support stops here.
-  if (!ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics))
-    return InverseMarking::forInverse(Kind::None);
-
-  /// The invertible protocol being targeted by this annotation request.
-
-  std::function<bool(Type)> isTarget = [&](Type t) -> bool {
-    if (auto kp = t->getKnownProtocol()) {
-      if (auto ip = getInvertibleProtocolKind(*kp))
-        return *ip == TARGET;
-    } else if (auto pct = t->getAs<ProtocolCompositionType>()) {
-      return llvm::any_of(pct->getMembers(), isTarget);
-    }
-
-    return false;
-  };
-
-  auto isInverseTarget = [&](Type t) -> bool {
-    if (auto pct = t->getAs<ProtocolCompositionType>())
-      return pct->getInverses().contains(TARGET);
-
-    return false;
-  };
-
-  auto resolveRequirement = [&](GenericContext *GC,
-                                unsigned reqIdx) -> std::optional<Requirement> {
-    auto req = evaluator(
-        RequirementRequest{GC, reqIdx, TypeResolutionStage::Structural}, [&]() {
-          return Requirement(RequirementKind::SameType, ErrorType::get(ctx),
-                             ErrorType::get(ctx));
-        });
-
-    if (req.hasError())
-      return std::nullopt;
-
-    return req;
-  };
-
-  // Function to check an inheritance clause for the ~IP marking.
-  auto searchInheritanceClause =
-      [&](InheritedTypes inherited) -> InverseMarking {
-    InverseMarking result;
-
-    for (size_t i = 0; i < inherited.size(); i++) {
-      auto type = inherited.getResolvedType(i, TypeResolutionStage::Structural);
-      if (!type)
-        continue;
-
-      SourceLoc loc;
-      if (auto *repr = inherited.getTypeRepr(i))
-        loc = repr->getLoc();
-
-      if (isTarget(type))
-        result.positive.setIfUnset(Kind::Explicit, loc);
-
-      if (isInverseTarget(type))
-        result.inverse.setIfUnset(Kind::Explicit, loc);
-    }
-
-    return result;
-  };
-
-  // Function to check the generic parameters for an explicit ~TARGET marking
-  // which would result in an Inferred ~TARGET marking for this context.
-  auto hasInferredInverseTarget = [&](GenericContext *genCtx) -> Mark {
-    auto *gpList = genCtx->getParsedGenericParams();
-    if (!gpList)
-      return InverseMarking::Mark();
-
-    llvm::SmallSet<GenericTypeParamDecl*, 4> params;
-
-    // Scan the inheritance clauses of generic parameters only for an inverse.
-    for (GenericTypeParamDecl *param : gpList->getParams()) {
-      auto clause = searchInheritanceClause(param->getInherited());
-      if (auto &inverse = clause.getInverse())
-        return inverse.with(Kind::Inferred);
-
-      params.insert(param);
-    }
-
-    Mark result;
-    // Next, scan the where clause and return the result.
-    auto whereClause = genCtx->getTrailingWhereClause();
-    if (!whereClause)
-      return result;
-
-    auto requirements = whereClause->getRequirements();
-    for (unsigned i : indices(requirements)) {
-      auto requirementRepr = requirements[i];
-      if (requirementRepr.getKind() != RequirementReprKind::TypeConstraint)
-        continue;
-
-      auto *constraintRepr =
-          dyn_cast<InverseTypeRepr>(requirementRepr.getConstraintRepr());
-      if (!constraintRepr || constraintRepr->isInvalid())
-        continue;
-
-      auto req = resolveRequirement(genCtx, i);
-      if (!req)
-        continue;
-
-      if (req->getKind() != RequirementKind::Conformance)
-        continue;
-
-      auto subject = req->getFirstType();
-      if (!subject->isTypeParameter())
-        continue;
-
-      // Skip outer params and implicit ones.
-      auto *param = subject->getRootGenericParam()->getDecl();
-      if (!param || !params.contains(param))
-        continue;
-
-      if (isInverseTarget(req->getSecondType())) {
-        result.set(Kind::Inferred, constraintRepr->getLoc());
-        break;
-      }
-    }
-
-    return result;
-  };
-
-  /// MARK: procedure for determining if a nominal is marked with ~TARGET.
-
-  auto *nominal = dyn_cast<NominalTypeDecl>(decl);
-  if (!nominal)
-    return InverseMarking::forInverse(Kind::None);
-
-  // Claim that the tuple decl has an inferred ~TARGET marking.
-  if (isa<BuiltinTupleDecl>(nominal))
-    return InverseMarking::forInverse(InverseMarking::Kind::Inferred);
-
-  // Handle non-protocol nominals specially because they infer a ~TARGET
-  // based on their generic parameters.
-  auto result = searchInheritanceClause(nominal->getInherited());
-  result.inverse.setIfUnset(hasInferredInverseTarget(nominal));
-  return result;
-}
-
 bool
 IsStaticRequest::evaluate(Evaluator &evaluator, FuncDecl *decl) const {
   if (auto *accessor = dyn_cast<AccessorDecl>(decl))