[TypeChecker] Requestify DynamicCallableAttribute check

Author: LucianoPAlmeida

include/swift/AST/TypeCheckRequests.h

@@ -1999,6 +1999,29 @@ class HasDynamicMemberLookupAttributeRequest
   }
 };
 
+/// Computes whether the specified type or a super-class/super-protocol has the
+/// @dynamicCallable attribute on it.
+class HasDynamicCallableAttributeRequest
+    : public SimpleRequest<HasDynamicCallableAttributeRequest,
+                           bool(CanType), CacheKind::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<bool> evaluate(Evaluator &evaluator, CanType ty) const;
+
+public:
+  bool isCached() const {
+    // Don't cache types containing type variables, as they must not outlive
+    // the constraint system that created them.
+    auto ty = std::get<0>(getStorage());
+    return !ty->hasTypeVariable();
+  }
+};
+
 /// Determines the type of a given pattern.
 ///
 /// Note that this returns the "raw" pattern type, which can involve

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -81,6 +81,8 @@ SWIFT_REQUEST(TypeChecker, HasCircularRawValueRequest,
               bool(EnumDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, HasDynamicMemberLookupAttributeRequest,
               bool(CanType), Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, HasDynamicCallableAttributeRequest,
+              bool(CanType), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, InferredGenericSignatureRequest,
               GenericSignature (ModuleDecl *, GenericSignatureImpl *,
                                  GenericParamList *,

include/swift/AST/Types.h

@@ -836,6 +836,10 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// Return true if the specified type or a super-class/super-protocol has the
   /// @dynamicMemberLookup attribute on it.
   bool hasDynamicMemberLookupAttribute();
+  
+  /// Return true if the specified type or a super-class/super-protocol has the
+  /// @dynamicCallable attribute on it.
+  bool hasDynamicCallableAttribute();
 
   /// Retrieve the superclass of this type.
   ///

lib/AST/Type.cpp

@@ -1499,6 +1499,13 @@ bool TypeBase::hasDynamicMemberLookupAttribute() {
       ctx.evaluator, HasDynamicMemberLookupAttributeRequest{canTy}, false);
 }
 
+bool TypeBase::hasDynamicCallableAttribute() {
+  auto canTy = getCanonicalType();
+  auto &ctx = canTy->getASTContext();
+  return evaluateOrDefault(
+      ctx.evaluator, HasDynamicCallableAttributeRequest{canTy}, false);
+}
+
 Type TypeBase::getSuperclass(bool useArchetypes) {
   auto *nominalDecl = getAnyNominal();
   auto *classDecl = dyn_cast_or_null<ClassDecl>(nominalDecl);

lib/Sema/ConstraintSystem.cpp

@@ -515,8 +515,7 @@ ConstraintLocator *ConstraintSystem::getCalleeLocator(
     }
 
     // Handling an apply for a nominal type that supports @dynamicCallable.
-    auto nominal = fnTy->getAnyNominal();
-    if (nominal && nominal->getAttrs().hasAttribute<DynamicCallableAttr>()) {
+    if (fnTy->hasDynamicCallableAttribute()) {
       return getConstraintLocator(anchor, LocatorPathElt::ApplyFunction());
     }
 

lib/Sema/TypeCheckConstraints.cpp

@@ -4233,18 +4233,18 @@ IsCallableNominalTypeRequest::evaluate(Evaluator &evaluator, CanType ty,
   });
 }
 
-llvm::Expected<bool>
-HasDynamicMemberLookupAttributeRequest::evaluate(Evaluator &evaluator,
-                                                 CanType ty) const {
+template <class DynamicAttribute>
+static bool checkForDynamicAttribute(CanType ty,
+                                     llvm::function_ref<bool (Type)> hasAttribute) {
   // If this is an archetype type, check if any types it conforms to
   // (superclass or protocols) have the attribute.
   if (auto archetype = dyn_cast<ArchetypeType>(ty)) {
     for (auto proto : archetype->getConformsTo()) {
-      if (proto->getDeclaredType()->hasDynamicMemberLookupAttribute())
+      if (hasAttribute(proto->getDeclaredType()))
         return true;
     }
     if (auto superclass = archetype->getSuperclass()) {
-      if (superclass->hasDynamicMemberLookupAttribute())
+      if (hasAttribute(superclass))
         return true;
     }
   }
@@ -4253,33 +4253,50 @@ HasDynamicMemberLookupAttributeRequest::evaluate(Evaluator &evaluator,
   // attribute.
   if (auto protocolComp = dyn_cast<ProtocolCompositionType>(ty)) {
     for (auto member : protocolComp->getMembers()) {
-      if (member->hasDynamicMemberLookupAttribute())
+      if (hasAttribute(member))
         return true;
     }
   }
 
   // Otherwise, this must be a nominal type.
-  // Dynamic member lookup doesn't work for tuples, etc.
+  // Neither Dynamic member lookup or Dynamic Callable doesn't
+  // work for tuples, etc.
   auto nominal = ty->getAnyNominal();
   if (!nominal)
     return false;
 
   // If this type has the attribute on it, then yes!
-  if (nominal->getAttrs().hasAttribute<DynamicMemberLookupAttr>())
+  if (nominal->getAttrs().hasAttribute<DynamicAttribute>())
     return true;
 
   // Check the protocols the type conforms to.
   for (auto proto : nominal->getAllProtocols()) {
-    if (proto->getDeclaredType()->hasDynamicMemberLookupAttribute())
+    if (hasAttribute(proto->getDeclaredType()))
       return true;
   }
 
   // Check the superclass if present.
   if (auto classDecl = dyn_cast<ClassDecl>(nominal)) {
     if (auto superclass = classDecl->getSuperclass()) {
-      if (superclass->hasDynamicMemberLookupAttribute())
+      if (hasAttribute(superclass))
         return true;
     }
   }
   return false;
 }
+
+llvm::Expected<bool>
+HasDynamicMemberLookupAttributeRequest::evaluate(Evaluator &evaluator,
+                                                 CanType ty) const {
+  return checkForDynamicAttribute<DynamicMemberLookupAttr>(ty, [](Type type) {
+    return type->hasDynamicMemberLookupAttribute();
+  });
+}
+
+llvm::Expected<bool>
+HasDynamicCallableAttributeRequest::evaluate(Evaluator &evaluator,
+                                             CanType ty) const {
+  return checkForDynamicAttribute<DynamicCallableAttr>(ty, [](Type type) {
+    return type->hasDynamicCallableAttribute();
+  });
+}