Requestify hasDynamicMemberLookupAttribute for Sema too

hamishknight · hamishknight · commit 36cecb4015e5 · 2019-12-13T11:04:00.000-08:00
Previously we had a request for this in
IDETypeChecking, but this wasn't used for queries
made from Sema. Move the request into Sema, and
move `hasDynamicMemberLookupAttribute` onto
TypeBase.
diff --git a/include/swift/AST/Type.h b/include/swift/AST/Type.h
@@ -371,6 +371,9 @@ class Type {
   void operator!=(Type T) const = delete;
 };
 
+/// Extract the source location from a given type.
+SourceLoc extractNearestSourceLoc(Type ty);
+
 /// CanType - This is a Type that is statically known to be canonical.  To get
 /// one of these, use Type->getCanonicalType().  Since all CanType's can be used
 /// as 'Type' (they just don't have sugar) we derive from Type.
diff --git a/include/swift/AST/TypeCheckRequests.h b/include/swift/AST/TypeCheckRequests.h
@@ -1968,6 +1968,29 @@ class TypeCheckSourceFileRequest :
   void cacheResult(bool result) const;
 };
 
+/// Computes whether the specified type or a super-class/super-protocol has the
+/// @dynamicMemberLookup attribute on it.
+class HasDynamicMemberLookupAttributeRequest
+    : public SimpleRequest<HasDynamicMemberLookupAttributeRequest,
+                           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();
+  }
+};
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>
diff --git a/include/swift/AST/TypeCheckerTypeIDZone.def b/include/swift/AST/TypeCheckerTypeIDZone.def
@@ -73,6 +73,8 @@ SWIFT_REQUEST(TypeChecker, HasCircularInheritedProtocolsRequest,
               bool(ProtocolDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, HasCircularRawValueRequest,
               bool(EnumDecl *), Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, HasDynamicMemberLookupAttributeRequest,
+              bool(CanType), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, InferredGenericSignatureRequest,
               GenericSignature (ModuleDecl *, GenericSignatureImpl *,
                                  GenericParamList *,
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -829,6 +829,10 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// check access control.
   bool isCallableNominalType(DeclContext *dc);
 
+  /// Return true if the specified type or a super-class/super-protocol has the
+  /// @dynamicMemberLookup attribute on it.
+  bool hasDynamicMemberLookupAttribute();
+
   /// Retrieve the superclass of this type.
   ///
   /// \param useArchetypes Whether to use context archetypes for outer generic
diff --git a/include/swift/Sema/IDETypeChecking.h b/include/swift/Sema/IDETypeChecking.h
@@ -232,10 +232,6 @@ namespace swift {
   /// written by the user; this performs the reverse transformation.
   OriginalArgumentList getOriginalArgumentList(Expr *expr);
 
-  /// Return true if the specified type or a super-class/super-protocol has the
-  /// @dynamicMemberLookup attribute on it.
-  bool hasDynamicMemberLookupAttribute(Type type);
-
   /// Returns the root type and result type of the keypath type in a keypath
   /// dynamic member lookup subscript, or \c None if it cannot be determined.
   ///
diff --git a/include/swift/Sema/IDETypeCheckingRequestIDZone.def b/include/swift/Sema/IDETypeCheckingRequestIDZone.def
@@ -15,8 +15,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-SWIFT_REQUEST(IDETypeChecking, HasDynamicMemberLookupAttributeRequest,
-              bool(TypeBase *), Cached, NoLocationInfo)
 SWIFT_REQUEST(IDETypeChecking, IsDeclApplicableRequest,
               bool(DeclApplicabilityOwner), Cached, NoLocationInfo)
 SWIFT_REQUEST(IDETypeChecking, RootAndResultTypeOfKeypathDynamicMemberRequest,
diff --git a/include/swift/Sema/IDETypeCheckingRequests.h b/include/swift/Sema/IDETypeCheckingRequests.h
@@ -227,29 +227,6 @@ class RootTypeOfKeypathDynamicMemberRequest:
   SourceLoc getNearestLoc() const { return SourceLoc(); };
 };
 
-//----------------------------------------------------------------------------//
-// HasDynamicMemberLookupAttributeRequest
-//----------------------------------------------------------------------------//
-class HasDynamicMemberLookupAttributeRequest:
-    public SimpleRequest<HasDynamicMemberLookupAttributeRequest,
-                         bool(TypeBase*),
-                         CacheKind::Cached> {
-public:
-  using SimpleRequest::SimpleRequest;
-
-private:
-  friend SimpleRequest;
-
-  // Evaluation.
-  llvm::Expected<bool> evaluate(Evaluator &evaluator, TypeBase *ty) const;
-
-public:
-  // Caching
-  bool isCached() const { return true; }
-  // Source location
-  SourceLoc getNearestLoc() const { return SourceLoc(); };
-};
-
 /// The zone number for the IDE.
 #define SWIFT_TYPEID_ZONE IDETypeChecking
 #define SWIFT_TYPEID_HEADER "swift/Sema/IDETypeCheckingRequestIDZone.def"
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -1498,6 +1498,13 @@ bool TypeBase::isCallableNominalType(DeclContext *dc) {
                            IsCallableNominalTypeRequest{canTy, dc}, false);
 }
 
+bool TypeBase::hasDynamicMemberLookupAttribute() {
+  auto canTy = getCanonicalType();
+  auto &ctx = canTy->getASTContext();
+  return evaluateOrDefault(
+      ctx.evaluator, HasDynamicMemberLookupAttributeRequest{canTy}, false);
+}
+
 Type TypeBase::getSuperclass(bool useArchetypes) {
   auto *nominalDecl = getAnyNominal();
   auto *classDecl = dyn_cast_or_null<ClassDecl>(nominalDecl);
@@ -4857,3 +4864,10 @@ SILFunctionType::withSubstitutions(SubstitutionMap subs) const {
                           subs, isGenericSignatureImplied(),
                           const_cast<SILFunctionType*>(this)->getASTContext());
 }
+
+SourceLoc swift::extractNearestSourceLoc(Type ty) {
+  if (auto nominal = ty->getAnyNominal())
+    return extractNearestSourceLoc(nominal);
+
+  return SourceLoc();
+}
diff --git a/lib/IDE/IDETypeChecking.cpp b/lib/IDE/IDETypeChecking.cpp
@@ -759,8 +759,3 @@ Type swift::getResultTypeOfKeypathDynamicMember(SubscriptDecl *SD) {
     RootAndResultTypeOfKeypathDynamicMemberRequest{SD}, TypePair()).
       SecondTy;
 }
-
-bool swift::hasDynamicMemberLookupAttribute(Type ty) {
-  return evaluateOrDefault(ty->getASTContext().evaluator,
-    HasDynamicMemberLookupAttributeRequest{ty.getPointer()}, false);
-}
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
@@ -5186,85 +5186,6 @@ ConstraintSystem::simplifyFunctionComponentConstraint(
   return SolutionKind::Solved;
 }
 
-/// Return true if the specified type or a super-class/super-protocol has the
-/// @dynamicMemberLookup attribute on it.  This implementation is not
-/// particularly fast in the face of deep class hierarchies or lots of protocol
-/// conformances, but this is fine because it doesn't get invoked in the normal
-/// name lookup path (only when lookup is about to fail).
-bool swift::hasDynamicMemberLookupAttribute(Type type,
-                    llvm::DenseMap<CanType, bool> &DynamicMemberLookupCache) {
-  auto canType = type->getCanonicalType();
-  auto it = DynamicMemberLookupCache.find(canType);
-  if (it != DynamicMemberLookupCache.end()) return it->second;
-
-  // Calculate @dynamicMemberLookup attribute for composite types with multiple
-  // components (protocol composition types and archetypes).
-  auto calculateForComponentTypes =
-      [&](ArrayRef<Type> componentTypes) -> bool {
-    for (auto componentType : componentTypes)
-      if (hasDynamicMemberLookupAttribute(componentType,
-                                          DynamicMemberLookupCache))
-        return true;
-    return false;
-  };
-
-  auto calculate = [&]() -> bool {
-    // 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>(canType)) {
-      SmallVector<Type, 2> componentTypes;
-      for (auto protocolDecl : archetype->getConformsTo())
-        componentTypes.push_back(protocolDecl->getDeclaredType());
-      if (auto superclass = archetype->getSuperclass())
-        componentTypes.push_back(superclass);
-      return calculateForComponentTypes(componentTypes);
-    }
-
-    // If this is a protocol composition, check if any of its members have the
-    // attribute.
-    if (auto protocolComp = dyn_cast<ProtocolCompositionType>(canType))
-      return calculateForComponentTypes(protocolComp->getMembers());
-
-    // Otherwise, this must be a nominal type.
-    // Dynamic member lookup doesn't work for tuples, etc.
-    auto nominal = canType->getAnyNominal();
-    if (!nominal) return false;
-
-    // If this type conforms to a protocol with the attribute, then return true.
-    for (auto p : nominal->getAllProtocols())
-      if (p->getAttrs().hasAttribute<DynamicMemberLookupAttr>())
-        return true;
-    
-    // Walk superclasses, if present.
-    llvm::SmallPtrSet<const NominalTypeDecl*, 8> visitedDecls;
-    while (1) {
-      // If we found a circular parent class chain, reject this.
-      if (!visitedDecls.insert(nominal).second)
-        return false;
-      
-      // If this type has the attribute on it, then yes!
-      if (nominal->getAttrs().hasAttribute<DynamicMemberLookupAttr>())
-        return true;
-      
-      // If this is a class with a super class, check super classes as well.
-      if (auto *cd = dyn_cast<ClassDecl>(nominal)) {
-        if (auto superClass = cd->getSuperclassDecl()) {
-          nominal = superClass;
-          continue;
-        }
-      }
-      
-      return false;
-    }
-  };
-  
-  auto result = calculate();
-  // Cache the result if the type does not contain type variables.
-  if (!type->hasTypeVariable())
-    DynamicMemberLookupCache[canType] = result;
-  return result;
-}
-
 static bool isForKeyPathSubscript(ConstraintSystem &cs,
                                   ConstraintLocator *locator) {
   if (!locator || !locator->getAnchor())
@@ -5738,9 +5659,7 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
     // as representing "dynamic lookup" unless it's a direct call
     // to such subscript (in that case label is expected to match).
     if (auto *subscript = dyn_cast<SubscriptDecl>(cand)) {
-      if (memberLocator &&
-          ::hasDynamicMemberLookupAttribute(instanceTy,
-                                            DynamicMemberLookupCache) &&
+      if (memberLocator && instanceTy->hasDynamicMemberLookupAttribute() &&
           isValidKeyPathDynamicMemberLookup(subscript)) {
         auto info = getArgumentInfo(memberLocator);
 
@@ -5829,7 +5748,7 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
   // parameter.
   if (constraintKind == ConstraintKind::ValueMember &&
       memberName.isSimpleName() && !memberName.isSpecial() &&
-      ::hasDynamicMemberLookupAttribute(instanceTy, DynamicMemberLookupCache)) {
+      instanceTy->hasDynamicMemberLookupAttribute()) {
     const auto &candidates = result.ViableCandidates;
 
     if ((candidates.empty() ||
diff --git a/lib/Sema/ConstraintSystem.h b/lib/Sema/ConstraintSystem.h
@@ -1297,9 +1297,6 @@ class ConstraintSystem {
   /// types.
   llvm::DenseMap<CanType, DynamicCallableMethods> DynamicCallableCache;
 
-  /// A cache that stores whether types are valid @dynamicMemberLookup types.
-  llvm::DenseMap<CanType, bool> DynamicMemberLookupCache;
-
 private:
   /// Describe the candidate expression for partial solving.
   /// This class used by shrink & solve methods which apply
diff --git a/lib/Sema/IDETypeCheckingRequests.cpp b/lib/Sema/IDETypeCheckingRequests.cpp
@@ -128,10 +128,3 @@ RootAndResultTypeOfKeypathDynamicMemberRequest::evaluate(Evaluator &evaluator,
          "invalid keypath dynamic member");
   return TypePair(genericArgs[0], genericArgs[1]);
 }
-
-llvm::Expected<bool>
-HasDynamicMemberLookupAttributeRequest::evaluate(Evaluator &evaluator,
-                                                 TypeBase *ty) const {
-  llvm::DenseMap<CanType, bool> DynamicMemberLookupCache;
-  return hasDynamicMemberLookupAttribute(Type(ty), DynamicMemberLookupCache);
-}
diff --git a/lib/Sema/LookupVisibleDecls.cpp b/lib/Sema/LookupVisibleDecls.cpp
@@ -986,8 +986,7 @@ static void lookupVisibleDynamicMemberLookupDecls(
   if (!seenDynamicLookup.insert(baseType.getPointer()).second)
     return;
 
-  if (!evaluateOrDefault(dc->getASTContext().evaluator,
-         HasDynamicMemberLookupAttributeRequest{baseType.getPointer()}, false))
+  if (!baseType->hasDynamicMemberLookupAttribute())
     return;
 
   auto &ctx = dc->getASTContext();
diff --git a/lib/Sema/TypeCheckConstraints.cpp b/lib/Sema/TypeCheckConstraints.cpp
@@ -4580,3 +4580,54 @@ IsCallableNominalTypeRequest::evaluate(Evaluator &evaluator, CanType ty,
     return false;
   });
 }
+
+llvm::Expected<bool>
+HasDynamicMemberLookupAttributeRequest::evaluate(Evaluator &evaluator,
+                                                 CanType ty) const {
+  // 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())
+        return true;
+    }
+    if (auto superclass = archetype->getSuperclass()) {
+      if (superclass->hasDynamicMemberLookupAttribute())
+        return true;
+    }
+  }
+
+  // If this is a protocol composition, check if any of its members have the
+  // attribute.
+  if (auto protocolComp = dyn_cast<ProtocolCompositionType>(ty)) {
+    for (auto member : protocolComp->getMembers()) {
+      if (member->hasDynamicMemberLookupAttribute())
+        return true;
+    }
+  }
+
+  // Otherwise, this must be a nominal type.
+  // Dynamic member lookup 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>())
+    return true;
+
+  // Check the protocols the type conforms to.
+  for (auto proto : nominal->getAllProtocols()) {
+    if (proto->getDeclaredType()->hasDynamicMemberLookupAttribute())
+      return true;
+  }
+
+  // Check the superclass if present.
+  if (auto classDecl = dyn_cast<ClassDecl>(nominal)) {
+    if (auto superclass = classDecl->getSuperclass()) {
+      if (superclass->hasDynamicMemberLookupAttribute())
+        return true;
+    }
+  }
+  return false;
+}
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
@@ -1740,9 +1740,6 @@ bool areGenericRequirementsSatisfied(const DeclContext *DC,
                                      GenericSignature sig,
                                      SubstitutionMap Substitutions,
                                      bool isExtension);
-
-bool hasDynamicMemberLookupAttribute(Type type,
-  llvm::DenseMap<CanType, bool> &DynamicMemberLookupCache);
 } // end namespace swift
 
 #endif

Original file line number	Diff line number	Diff line change
`@@ -759,8 +759,3 @@ Type swift::getResultTypeOfKeypathDynamicMember(SubscriptDecl *SD) {`
`759`	`759`	`RootAndResultTypeOfKeypathDynamicMemberRequest{SD}, TypePair()).`
`760`	`760`	`SecondTy;`
`761`	`761`	`}`
`762`		`-`
`763`		`-bool swift::hasDynamicMemberLookupAttribute(Type ty) {`
`764`		`- return evaluateOrDefault(ty->getASTContext().evaluator,`
`765`		`- HasDynamicMemberLookupAttributeRequest{ty.getPointer()}, false);`
`766`		`-}`