Merge pull request #59207 from Huddie/update-cxx-operator-impl-templates-off

[cxx interoperability] Turn off non subscript templated operators

Author: zoecarver

lib/ClangImporter/ClangImporter.cpp

@@ -78,7 +78,6 @@
 #include <algorithm>
 #include <string>
 #include <memory>
-#include <string>
 
 using namespace swift;
 using namespace importer;

lib/ClangImporter/ImportDecl.cpp

@@ -4153,6 +4153,17 @@ namespace {
       if (!dc)
         return nullptr;
 
+      bool isOperator = decl->getDeclName().getNameKind() ==
+                        clang::DeclarationName::CXXOperatorName;
+      bool isNonSubscriptOperator =
+          isOperator && (decl->getDeclName().getCXXOverloadedOperator() !=
+                         clang::OO_Subscript);
+
+      // For now, we don't support non-subscript operators which are templated
+      if (isNonSubscriptOperator && decl->isTemplated()) {
+        return nullptr;
+      }
+
       // Handle cases where 2 CXX methods differ strictly in "constness"
       // In such a case append a suffix ("Mutating") to the mutable version
       // of the method when importing to swift

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

@@ -186,11 +186,24 @@ template<class T> struct TemplatedArrayByVal {
   T ts[];
   T operator[](int i) { return ts[i]; }
 };
+
 typedef TemplatedArrayByVal<double> TemplatedDoubleArrayByVal;
 
-struct TemplatedSubscriptArrayByVal {
+template <class T>
+struct TemplatedByVal {
+  T val;
+  TemplatedByVal<T> operator+(TemplatedByVal other) {
+    return TemplatedByVal{.val = val + other.val};
+  }
+};
+
+struct TemplatedOperatorArrayByVal {
   int *ptr;
   template<class T> T operator[](T i) { return ptr[i]; }
+  template <class T>
+  T *operator+(T i) {
+    return ptr + i;
+  }
 };
 
 struct NonTrivial {

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

@@ -133,11 +133,14 @@
 // CHECK: }
 // CHECK: typealias TemplatedDoubleArrayByVal = __CxxTemplateInst19TemplatedArrayByValIdE
 
+// CHECK: struct TemplatedByVal<T> {
+// CHECK-NEXT: }
 
-// CHECK: struct TemplatedSubscriptArrayByVal {
+// CHECK: struct TemplatedOperatorArrayByVal {
 // CHECK:   subscript(i: T) -> T { mutating get }
 // CHECK:   @available(*, unavailable, message: "use subscript")
 // CHECK:   mutating func __operatorSubscriptConst<T>(_ i: T) -> T
+// CHECK-NOT: mutating func __operatorPlus<T>(_ i: T) -> UnsafeMutablePointer<T>
 // CHECK: }
 
 // CHECK: struct NonTrivialArrayByVal {