[cxx-interop] Import iterator dereference operators

Author: egorzhdan

lib/ClangImporter/ImportDecl.cpp

@@ -3596,8 +3596,10 @@ namespace {
             auto cxxOperatorKind = cxxMethod->getOverloadedOperator();
 
             // Check if this method _is_ an overloaded operator but is not a
-            // call / subscript. Those 2 operators do not need static versions
-            if (cxxOperatorKind != clang::OverloadedOperatorKind::OO_None &&
+            // call / subscript / dereference. Those 3 operators do not need
+            // static versions.
+            if (!isCXXDereferenceOperator(cxxMethod) &&
+                cxxOperatorKind != clang::OverloadedOperatorKind::OO_None &&
                 cxxOperatorKind != clang::OverloadedOperatorKind::OO_Call &&
                 cxxOperatorKind !=
                     clang::OverloadedOperatorKind::OO_Subscript) {
@@ -8872,6 +8874,11 @@ bool importer::isSpecialUIKitStructZeroProperty(const clang::NamedDecl *decl) {
   return ident->isStr("UIEdgeInsetsZero") || ident->isStr("UIOffsetZero");
 }
 
+bool importer::isCXXDereferenceOperator(const clang::FunctionDecl *decl) {
+  return decl->getOverloadedOperator() == clang::OO_Star &&
+         isa<clang::CXXMethodDecl>(decl) && decl->param_empty();
+}
+
 bool importer::hasSameUnderlyingType(const clang::Type *a,
                                      const clang::TemplateTypeParmDecl *b) {
   while (a->isPointerType() || a->isReferenceType())

lib/ClangImporter/ImportName.cpp

@@ -1838,9 +1838,18 @@ ImportedName NameImporter::importNameImpl(const clang::NamedDecl *D,
       return ImportedName();
 
     switch (op) {
+    case clang::OverloadedOperatorKind::OO_Star: {
+      if (isCXXDereferenceOperator(functionDecl)) {
+        // This is not an arithmetic operator, and it is handled differently.
+        baseName = "dereference";
+        isFunction = true;
+        break;
+      }
+      // This is a multiplication operator.
+      LLVM_FALLTHROUGH;
+    }
     case clang::OverloadedOperatorKind::OO_Plus:
     case clang::OverloadedOperatorKind::OO_Minus:
-    case clang::OverloadedOperatorKind::OO_Star:
     case clang::OverloadedOperatorKind::OO_Slash:
     case clang::OverloadedOperatorKind::OO_Percent:
     case clang::OverloadedOperatorKind::OO_Caret:

lib/ClangImporter/ImporterImpl.h

@@ -1771,6 +1771,9 @@ bool shouldSuppressDeclImport(const clang::Decl *decl);
 /// but are now renamed using the swift_name attribute.
 bool isSpecialUIKitStructZeroProperty(const clang::NamedDecl *decl);
 
+/// Whether this is a C++ `operator*()`.
+bool isCXXDereferenceOperator(const clang::FunctionDecl *decl);
+
 /// \returns true if \p a has the same underlying type as \p b after removing
 /// any pointer/reference specifiers. Note that this does not currently look through
 /// nested types other than pointers or references.

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

@@ -274,4 +274,18 @@ struct DerivedFromReadWriteIntArray : ReadWriteIntArray {};
 
 struct DerivedFromNonTrivialArrayByVal : NonTrivialArrayByVal {};
 
+struct Iterator {
+private:
+  int value = 123;
+public:
+  int &operator*() { return value; }
+};
+
+struct ConstIterator {
+private:
+  int value = 234;
+public:
+  const int &operator*() const { return value; }
+};
+
 #endif

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

@@ -190,3 +190,11 @@
 // CHECK:   subscript(x: Int32) -> NonTrivial { get }
 // CHECK:   mutating func __operatorSubscriptConst(_ x: Int32) -> NonTrivial
 // CHECK: }
+
+// CHECK: struct Iterator {
+// CHECK:   mutating func dereference() -> UnsafeMutablePointer<Int32>
+// CHECK: }
+
+// CHECK: struct ConstIterator {
+// CHECK:   func dereference() -> UnsafePointer<Int32>
+// CHECK: }

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

@@ -240,4 +240,16 @@ OperatorsTestSuite.test("PtrToPtr.subscript (inline)") {
 //  expectEqual(23, arr[0])
 //}
 
+OperatorsTestSuite.test("Iterator.dereference") {
+  var iter = Iterator()
+  let res = iter.dereference()
+  expectEqual(123, res.pointee)
+}
+
+OperatorsTestSuite.test("ConstIterator.dereference") {
+  let iter = ConstIterator()
+  let res = iter.dereference()
+  expectEqual(234, res.pointee)
+}
+
 runAllTests()