[AST] Add TypeBase::findUnresolvedDependentMemberType() and use it 3x.

NFC: Eliminate some duplicated "search for an unresolved dependent
member type" code scattered around.

Author: DougGregor

include/swift/AST/Types.h

@@ -45,6 +45,7 @@ namespace swift {
   class AssociatedTypeDecl;
   class ASTContext;
   class ClassDecl;
+  class DependentMemberType;
   class GenericTypeParamDecl;
   class GenericTypeParamType;
   class GenericParamList;
@@ -534,6 +535,12 @@ class alignas(1 << TypeAlignInBits) TypeBase {
     return getRecursiveProperties().hasTypeParameter();
   }
 
+  /// Find any unresolved dependent member type within this type.
+  ///
+  /// "Unresolved" dependent member types have no known associated type,
+  /// and are only used transiently in the type checker.
+  const DependentMemberType *findUnresolvedDependentMemberType();
+
   /// Return the root generic parameter of this type parameter type.
   GenericTypeParamType *getRootGenericParam();
 

lib/AST/ASTVerifier.cpp

@@ -2575,18 +2575,8 @@ class Verifier : public ASTWalker {
       // dependent member types.
       // FIXME: This is a general property of the type system.
       auto interfaceTy = AFD->getInterfaceType();
-      Type unresolvedDependentTy;
-      interfaceTy.findIf([&](Type type) -> bool {
-        if (auto dependent = type->getAs<DependentMemberType>()) {
-          if (dependent->getAssocType() == nullptr) {
-            unresolvedDependentTy = dependent;
-            return true;
-          }
-        }
-        return false;
-      });
-
-      if (unresolvedDependentTy) {
+      if (auto unresolvedDependentTy
+            = interfaceTy->findUnresolvedDependentMemberType()) {
         Out << "Unresolved dependent member type ";
         unresolvedDependentTy->print(Out);
         abort();

lib/AST/GenericSignatureBuilder.cpp

@@ -5266,14 +5266,8 @@ static void collectRequirements(GenericSignatureBuilder &builder,
 
       // Drop requirements involving concrete types containing
       // unresolved associated types.
-      if (repTy.findIf([](Type t) -> bool {
-            if (auto *depTy = dyn_cast<DependentMemberType>(t.getPointer()))
-              if (depTy->getAssocType() == nullptr)
-                return true;
-            return false;
-          })) {
+      if (repTy->findUnresolvedDependentMemberType())
         return;
-      }
     } else if (auto layoutConstraint = type.dyn_cast<LayoutConstraint>()) {
       requirements.push_back(Requirement(kind, depTy, layoutConstraint));
       return;

lib/AST/Type.cpp

@@ -3156,6 +3156,24 @@ Type Type::substDependentTypesWithErrorTypes() const {
                     SubstFlags::UseErrorType));
 }
 
+const DependentMemberType *TypeBase::findUnresolvedDependentMemberType() {
+  if (!hasTypeParameter()) return nullptr;
+
+  const DependentMemberType *unresolvedDepMemTy = nullptr;
+  Type(this).findIf([&](Type type) -> bool {
+    if (auto depMemTy = type->getAs<DependentMemberType>()) {
+      if (depMemTy->getAssocType() == nullptr) {
+        unresolvedDepMemTy = depMemTy;
+        return true;
+      }
+    }
+    return false;
+  });
+
+  return unresolvedDepMemTy;
+}
+
+
 Type TypeBase::getSuperclassForDecl(const ClassDecl *baseClass) {
   Type t(this);
   while (t) {

lib/Sema/TypeCheckDecl.cpp

@@ -6954,18 +6954,6 @@ bool swift::checkOverrides(TypeChecker &TC, ValueDecl *decl) {
   return DeclChecker::checkOverrides(TC, decl);
 }
 
-/// Determine whether the given type contains an unresolved dependent member
-/// type.
-static bool hasUnresolvedDependentMemberType(Type type) {
-  return type.findIf([](Type type) {
-    if (auto depMemTy = type->getAs<DependentMemberType>()) {
-      if (!depMemTy->getAssocType()) return true;
-    }
-
-    return false;
-  });
-}
-
 bool TypeChecker::isAvailabilitySafeForOverride(ValueDecl *override,
                                                 ValueDecl *base) {
   // API availability ranges are contravariant: make sure the version range
@@ -7270,8 +7258,8 @@ void TypeChecker::validateDecl(ValueDecl *D) {
           // FIXME: We never should have recorded such a type in the first
           // place.
           if (!aliasDecl->getUnderlyingTypeLoc().getType() ||
-              hasUnresolvedDependentMemberType(
-                aliasDecl->getUnderlyingTypeLoc().getType())) {
+              aliasDecl->getUnderlyingTypeLoc().getType()
+                ->findUnresolvedDependentMemberType()) {
             aliasDecl->getUnderlyingTypeLoc().setType(Type(),
                                                       /*validated=*/false);
             validateAccessibility(aliasDecl);