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

Author: zoecarver

lib/ClangImporter/ClangImporter.cpp

@@ -2689,6 +2689,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) ||

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());
           }

lib/ClangImporter/SwiftLookupTable.cpp

@@ -808,11 +808,6 @@ SwiftLookupTable::lookupMemberOperators(SerializedSwiftName baseName) {
 
   // Walk each of the entries.
   for (auto &entry : known->second) {
-    // We're only looking for C++ operators
-    if (entry.Context.first != ContextKind::Tag) {
-      continue;
-    }
-
     // Map each of the declarations.
     for (auto &stored : entry.DeclsOrMacros) {
       assert(isDeclEntry(stored) && "Not a declaration?");

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

@@ -40,6 +40,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

@@ -69,6 +69,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/Inputs/module.modulemap

@@ -7,3 +7,8 @@ module StdString {
   header "std-string.h"
   requires cplusplus
 }
+
+module StdMap {
+  header "std-map.h"
+  requires cplusplus
+}

test/Interop/Cxx/stdlib/Inputs/std-map.h

@@ -0,0 +1,17 @@
+#ifndef TEST_INTEROP_CXX_STDLIB_INPUTS_STD_VECTOR_H
+#define TEST_INTEROP_CXX_STDLIB_INPUTS_STD_VECTOR_H
+
+#include <map>
+
+using Map = std::map<int, int>;
+
+inline Map initMap() {
+  Map map;
+  map[1] = 1;
+  map[2] = 2;
+  map[3] = 3;
+  map[4] = 4;
+  return map;
+}
+
+#endif // TEST_INTEROP_CXX_STDLIB_INPUTS_STD_VECTOR_H

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

@@ -0,0 +1,26 @@
+// RUN: %target-run-simple-swift(-I %S/Inputs -Xfrontend -enable-experimental-cxx-interop)
+//
+// REQUIRES: executable_test
+//
+// Enable this everywhere once we have a solution for modularizing libstdc++: rdar://87654514
+// REQUIRES: OS=macosx
+
+import StdlibUnittest
+import StdMap
+import std.map
+import Cxx
+
+var StdMapTestSuite = TestSuite("std::map")
+
+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()