[cxx-interop] Fix friend operators that come from class template specializations.

Author: zoecarver

lib/ClangImporter/ClangImporter.cpp

@@ -2712,6 +2712,11 @@ static bool isVisibleFromModule(const ClangModuleUnit *ModuleFilter,
   if (OwningClangModule == ModuleFilter->getClangModule())
     return true;
 
+  // Friends from class templates don't have an owning module. Just return true.
+  if (isa<clang::FunctionDecl>(D) &&
+      cast<clang::FunctionDecl>(D)->isThisDeclarationInstantiatedFromAFriendDefinition())
+    return true;
+
   // Handle redeclarable Clang decls by checking each redeclaration.
   bool IsTagDecl = isa<clang::TagDecl>(D);
   if (!(IsTagDecl || isa<clang::FunctionDecl>(D) || isa<clang::VarDecl>(D) ||
@@ -4124,7 +4129,13 @@ bool ClangImporter::Implementation::lookupValue(SwiftLookupTable &table,
 
     // If the name matched, report this result.
     bool anyMatching = false;
-    if (decl->getName().matchesRef(name) &&
+
+    // Use the base name for operators; they likely won't have parameters.
+    auto foundDeclName = decl->getName();
+    if (foundDeclName.isOperator())
+      foundDeclName = foundDeclName.getBaseName();
+
+    if (foundDeclName.matchesRef(name) &&
         decl->getDeclContext()->isModuleScopeContext()) {
       consumer.foundDecl(decl, DeclVisibilityKind::VisibleAtTopLevel);
       anyMatching = true;

lib/ClangImporter/ImportDecl.cpp

@@ -2139,7 +2139,16 @@ namespace {
         if (auto friendDecl = dyn_cast<clang::FriendDecl>(m)) {
           if (friendDecl->getFriendDecl()) {
             m = friendDecl->getFriendDecl();
-            auto lookupTable = Impl.findLookupTable(m->getOwningModule());
+
+            // Find the owning module of the class template. Members of class
+            // template specializations don't have an owning module.
+            clang::Module *owningModule = nullptr;
+            if (auto spec = dyn_cast<clang::ClassTemplateSpecializationDecl>(decl))
+              owningModule = spec->getSpecializedTemplate()->getOwningModule();
+            else
+              owningModule = decl->getOwningModule();
+
+            auto lookupTable = Impl.findLookupTable(owningModule);
             addEntryToLookupTable(*lookupTable, friendDecl->getFriendDecl(),
                                   Impl.getNameImporter());
           }
@@ -8241,6 +8250,15 @@ ClangImporter::Implementation::importDeclContextOf(
     if (dc->getDeclKind() == clang::Decl::LinkageSpec)
       dc = dc->getParent();
 
+    // Treat friend decls like top-level decls.
+    if (auto functionDecl = dyn_cast<clang::FunctionDecl>(decl)) {
+      if (functionDecl->getFriendObjectKind()) {
+        // Find the top-level decl context.
+        while (isa<clang::NamedDecl>(dc))
+          dc = dc->getParent();
+      }
+    }
+
     if (dc->isTranslationUnit()) {
       if (auto *module = getClangModuleForDecl(decl))
         return module;

test/Interop/Cxx/operators/Inputs/member-inline.h

@@ -50,6 +50,16 @@ struct LoadableBoolWrapper {
   }
 };
 
+template<class T>
+struct TemplatedWithFriendOperator {
+  friend bool operator==(const TemplatedWithFriendOperator &lhs,
+                         const TemplatedWithFriendOperator &rhs) {
+    return true;
+  }
+};
+
+using TemplatedWithFriendOperatorSpec = TemplatedWithFriendOperator<int>;
+
 struct __attribute__((swift_attr("import_owned"))) AddressOnlyIntWrapper {
   int value;
 

test/Interop/Cxx/operators/member-inline.swift

@@ -89,6 +89,15 @@ OperatorsTestSuite.test("LoadableIntWrapper.successor() (inline)") {
   expectEqual(42, wrapper.value)
 }
 
+OperatorsTestSuite.test("TemplatedWithFriendOperator.equal (inline)") {
+  let lhs = TemplatedWithFriendOperatorSpec()
+  let rhs = TemplatedWithFriendOperatorSpec()
+
+  let result = lhs == rhs
+
+  expectTrue(result)
+}
+
 #if !os(Windows)    // https://github.com/apple/swift/issues/55575
 OperatorsTestSuite.test("LoadableBoolWrapper.exclaim (inline)") {
   var wrapper = LoadableBoolWrapper(value: true)

test/Interop/Cxx/stdlib/use-std-map.swift

@@ -26,4 +26,15 @@ StdMapTestSuite.test("subscript") {
   expectEqual(m[3], 3)
 }
 
+extension Map.const_iterator : UnsafeCxxInputIterator { }
+extension Map : CxxSequence { }
+
+StdMapTestSuite.test("first(where:)") {
+    let m = initMap()
+    let found = m.first(where: { $0.first > 1 })
+
+    expectEqual(found!.first, 2)
+    expectEqual(found!.second, 2)
+}
+
 runAllTests()