[cxx-interop] Do not synthesize ambiguous pointee properties

If a C++ struct defines multiple overloads of `operator*`, avoid synthesizing multiple `var pointee: Pointee` properties, since that would introduce name resolution ambiguity. Instead, pick one of the const overloads and synthesize a single `pointee` property.

This is required for `std::optional` support.

Author: egorzhdan

lib/ClangImporter/ImportDecl.cpp

@@ -2127,6 +2127,17 @@ namespace {
       // The name of every member.
       llvm::DenseSet<StringRef> allMemberNames;
 
+      bool hasConstOperatorStar = false;
+      for (auto member : decl->decls()) {
+        if (auto method = dyn_cast<clang::CXXMethodDecl>(member)) {
+          if (method->getOverloadedOperator() ==
+                  clang::OverloadedOperatorKind::OO_Star &&
+              method->param_empty() && method->isConst())
+            hasConstOperatorStar = true;
+        }
+      }
+      bool hasSynthesizedPointeeProperty = false;
+
       // FIXME: Import anonymous union fields and support field access when
       // it is nested in a struct.
       for (auto m : decl->decls()) {
@@ -2210,9 +2221,16 @@ namespace {
             if (cxxOperatorKind == clang::OO_Star && cxxMethod->param_empty()) {
               // This is a dereference operator. We synthesize a computed
               // property called `pointee` for it.
-              VarDecl *pointeeProperty =
-                  synthesizer.makeDereferencedPointeeProperty(MD);
-              result->addMember(pointeeProperty);
+
+              // If this record has multiple overloads of `operator*`, prefer
+              // the const overload if it exists.
+              if ((cxxMethod->isConst() || !hasConstOperatorStar) &&
+                  !hasSynthesizedPointeeProperty) {
+                VarDecl *pointeeProperty =
+                    synthesizer.makeDereferencedPointeeProperty(MD);
+                result->addMember(pointeeProperty);
+                hasSynthesizedPointeeProperty = true;
+              }
 
               Impl.markUnavailable(MD, "use .pointee property");
               MD->overwriteAccess(AccessLevel::Private);

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

@@ -394,4 +394,21 @@ struct ConstIteratorByVal {
   int operator*() const { return value; }
 };
 
+struct AmbiguousOperatorStar {
+private:
+  int value = 567;
+public:
+  int &operator*() { return value; }
+  const int &operator*() const { return value; }
+};
+
+struct AmbiguousOperatorStar2 {
+private:
+  int value = 678;
+public:
+  int &operator*() & { return value; }
+  const int &operator*() const & { return value; }
+  const int &&operator*() const && { return static_cast<const int &&>(value); }
+};
+
 #endif

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

@@ -221,3 +221,23 @@
 // CHECK:   @available(*, unavailable, message: "use .pointee property")
 // CHECK:   func __operatorStar() -> Int32
 // CHECK: }
+
+// CHECK: struct AmbiguousOperatorStar {
+// CHECK-NEXT:   var pointee: Int32 { get }
+// CHECK-NEXT:   init()
+// CHECK-NEXT:   @available(*, unavailable, message: "use .pointee property")
+// CHECK-NEXT:   mutating func __operatorStar() -> UnsafeMutablePointer<Int32>
+// CHECK-NEXT:   @available(*, unavailable, message: "use .pointee property")
+// CHECK-NEXT:   func __operatorStar() -> UnsafePointer<Int32>
+// CHECK-NEXT: }
+
+// CHECK: struct AmbiguousOperatorStar2 {
+// CHECK-NEXT:   var pointee: Int32 { get }
+// CHECK-NEXT:   init()
+// CHECK-NEXT:   @available(*, unavailable, message: "use .pointee property")
+// CHECK-NEXT:   mutating func __operatorStar() -> UnsafeMutablePointer<Int32>
+// CHECK-NEXT:   @available(*, unavailable, message: "use .pointee property")
+// CHECK-NEXT:   func __operatorStar() -> UnsafePointer<Int32>
+// CHECK-NEXT:   @available(*, unavailable, message: "use .pointee property")
+// CHECK-NEXT:   func __operatorStar() -> UnsafePointer<Int32>
+// CHECK-NEXT: }

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

@@ -363,4 +363,16 @@ OperatorsTestSuite.test("ConstIteratorByVal.pointee") {
   expectEqual(456, res)
 }
 
+OperatorsTestSuite.test("AmbiguousOperatorStar.pointee") {
+  let stars = AmbiguousOperatorStar()
+  let res = stars.pointee
+  expectEqual(567, res)
+}
+
+OperatorsTestSuite.test("AmbiguousOperatorStar2.pointee") {
+  let stars = AmbiguousOperatorStar2()
+  let res = stars.pointee
+  expectEqual(678, res)
+}
+
 runAllTests()