[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());
           }
@@ -8239,6 +8248,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/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()