RequirementMachine: Factor out duplicated lookupConcreteNestedType() utility

Author: slavapestov

lib/AST/CMakeLists.txt

@@ -83,6 +83,7 @@ add_swift_host_library(swiftAST STATIC
   RequirementMachine/InterfaceType.cpp
   RequirementMachine/KnuthBendix.cpp
   RequirementMachine/MinimalConformances.cpp
+  RequirementMachine/NameLookup.cpp
   RequirementMachine/NormalizeRewritePath.cpp
   RequirementMachine/PropertyMap.cpp
   RequirementMachine/PropertyRelations.cpp

lib/AST/RequirementMachine/ConcreteContraction.cpp

@@ -146,6 +146,7 @@
 #include "swift/AST/Types.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
+#include "NameLookup.h"
 #include "RequirementLowering.h"
 
 using namespace swift;
@@ -182,30 +183,6 @@ class ConcreteContraction {
 
 }  // end namespace
 
-/// Find the most canonical member type of \p decl named \p name, using the
-/// canonical type order.
-static TypeDecl *lookupConcreteNestedType(ModuleDecl *module,
-                                          NominalTypeDecl *decl,
-                                          Identifier name) {
-  SmallVector<ValueDecl *, 2> foundMembers;
-  module->lookupQualified(
-      decl, DeclNameRef(name),
-      NL_QualifiedDefault | NL_OnlyTypes | NL_ProtocolMembers,
-      foundMembers);
-
-  SmallVector<TypeDecl *, 2> concreteDecls;
-  for (auto member : foundMembers)
-    concreteDecls.push_back(cast<TypeDecl>(member));
-
-  if (concreteDecls.empty())
-    return nullptr;
-
-  return *std::min_element(concreteDecls.begin(), concreteDecls.end(),
-                           [](TypeDecl *type1, TypeDecl *type2) {
-                             return TypeDecl::compare(type1, type2) < 0;
-                           });
-}
-
 /// A re-implementation of Type::subst() that also handles unresolved
 /// DependentMemberTypes by performing name lookup into the base type.
 ///
@@ -267,12 +244,12 @@ Optional<Type> ConcreteContraction::substTypeParameter(
     return None;
   }
 
-  auto *module = decl->getParentModule();
-
   // An unresolved DependentMemberType stores an identifier. Handle this
   // by performing a name lookup into the base type.
-  auto *typeDecl = lookupConcreteNestedType(module, decl,
-                                            memberType->getName());
+  SmallVector<TypeDecl *> concreteDecls;
+  lookupConcreteNestedType(decl, memberType->getName(), concreteDecls);
+
+  auto *typeDecl = findBestConcreteNestedType(concreteDecls);
   if (typeDecl == nullptr) {
     // The base type doesn't contain a member type with this name, in which
     // case the requirement remains unsubstituted.
@@ -285,7 +262,7 @@ Optional<Type> ConcreteContraction::substTypeParameter(
 
   // Substitute the base type into the member type.
   auto subMap = (*substBaseType)->getContextSubstitutionMap(
-      module, typeDecl->getDeclContext());
+      decl->getParentModule(), typeDecl->getDeclContext());
   return typeDecl->getDeclaredInterfaceType().subst(subMap);
 }
 

lib/AST/RequirementMachine/GenericSignatureQueries.cpp

@@ -14,13 +14,13 @@
 // Use those methods instead of calling into the RequirementMachine directly.
 //
 //===----------------------------------------------------------------------===//
+
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/Module.h"
-#include "llvm/ADT/TinyPtrVector.h"
 #include <vector>
-
+#include "NameLookup.h"
 #include "RequirementMachine.h"
 
 using namespace swift;
@@ -609,26 +609,6 @@ RequirementMachine::getConformanceAccessPath(Type type,
   }
 }
 
-static void lookupConcreteNestedType(NominalTypeDecl *decl,
-                                     Identifier name,
-                                     SmallVectorImpl<TypeDecl *> &concreteDecls) {
-  SmallVector<ValueDecl *, 2> foundMembers;
-  decl->getParentModule()->lookupQualified(
-      decl, DeclNameRef(name),
-      NL_QualifiedDefault | NL_OnlyTypes | NL_ProtocolMembers,
-      foundMembers);
-  for (auto member : foundMembers)
-    concreteDecls.push_back(cast<TypeDecl>(member));
-}
-
-static TypeDecl *
-findBestConcreteNestedType(SmallVectorImpl<TypeDecl *> &concreteDecls) {
-  return *std::min_element(concreteDecls.begin(), concreteDecls.end(),
-                           [](TypeDecl *type1, TypeDecl *type2) {
-                             return TypeDecl::compare(type1, type2) < 0;
-                           });
-}
-
 TypeDecl *
 RequirementMachine::lookupNestedType(Type depType, Identifier name) const {
   auto term = Context.getMutableTermForType(depType->getCanonicalType(),

lib/AST/RequirementMachine/NameLookup.cpp

@@ -0,0 +1,46 @@
+//===--- NameLookup.cpp - Name lookup utilities ---------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#include "NameLookup.h"
+#include "swift/AST/Decl.h"
+#include "swift/AST/Module.h"
+#include "llvm/ADT/SmallVector.h"
+#include <algorithm>
+
+using namespace swift;
+using namespace rewriting;
+
+void
+swift::rewriting::lookupConcreteNestedType(
+    NominalTypeDecl *decl,
+    Identifier name,
+    SmallVectorImpl<TypeDecl *> &concreteDecls) {
+  SmallVector<ValueDecl *, 2> foundMembers;
+  decl->getParentModule()->lookupQualified(
+      decl, DeclNameRef(name),
+      NL_QualifiedDefault | NL_OnlyTypes | NL_ProtocolMembers,
+      foundMembers);
+  for (auto member : foundMembers)
+    concreteDecls.push_back(cast<TypeDecl>(member));
+}
+
+TypeDecl *
+swift::rewriting::findBestConcreteNestedType(
+    SmallVectorImpl<TypeDecl *> &concreteDecls) {
+  if (concreteDecls.empty())
+    return nullptr;
+
+  return *std::min_element(concreteDecls.begin(), concreteDecls.end(),
+                           [](TypeDecl *type1, TypeDecl *type2) {
+                             return TypeDecl::compare(type1, type2) < 0;
+                           });
+}

lib/AST/RequirementMachine/NameLookup.h

@@ -0,0 +1,38 @@
+//===--- NameLookup.h - Name lookup utilities -------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_RQM_NAMELOOKUP_H
+#define SWIFT_RQM_NAMELOOKUP_H
+
+#include "llvm/ADT/SmallVector.h"
+
+namespace swift {
+
+class Identifier;
+class NominalTypeDecl;
+class TypeDecl;
+
+namespace rewriting {
+
+void lookupConcreteNestedType(
+    NominalTypeDecl *decl,
+    Identifier name,
+    llvm::SmallVectorImpl<TypeDecl *> &concreteDecls);
+
+TypeDecl *findBestConcreteNestedType(
+    llvm::SmallVectorImpl<TypeDecl *> &concreteDecls);
+
+} // end namespace rewriting
+
+} // end namespace swift
+
+#endif