[cxx-interop] Handle inherited templated operators during auto-conformance

This fixes the automatic `std::unordered_map` conformance to CxxDictionary on Linux. Previously `std::unordered_map::const_iterator` was not auto-conformed to UnsafeCxxInputIterator because its `operator==` is defined on a templated base class of `const_iterator`.

rdar://105220600

Author: egorzhdan

lib/ClangImporter/ClangDerivedConformances.cpp

@@ -156,7 +156,7 @@ static ValueDecl *getEqualEqualOperator(NominalTypeDecl *decl) {
   return lookupOperator(decl, decl->getASTContext().Id_EqualsOperator, isValid);
 }
 
-static ValueDecl *getMinusOperator(NominalTypeDecl *decl) {
+static FuncDecl *getMinusOperator(NominalTypeDecl *decl) {
   auto binaryIntegerProto =
       decl->getASTContext().getProtocol(KnownProtocolKind::BinaryInteger);
   auto module = decl->getModuleContext();
@@ -188,8 +188,9 @@ static ValueDecl *getMinusOperator(NominalTypeDecl *decl) {
     return true;
   };
 
-  return lookupOperator(decl, decl->getASTContext().getIdentifier("-"),
-                        isValid);
+  ValueDecl *result =
+      lookupOperator(decl, decl->getASTContext().getIdentifier("-"), isValid);
+  return dyn_cast_or_null<FuncDecl>(result);
 }
 
 static ValueDecl *getPlusEqualOperator(NominalTypeDecl *decl, Type distanceTy) {
@@ -223,10 +224,10 @@ static ValueDecl *getPlusEqualOperator(NominalTypeDecl *decl, Type distanceTy) {
                         isValid);
 }
 
-static void instantiateTemplatedOperator(
-    ClangImporter::Implementation &impl,
-    const clang::ClassTemplateSpecializationDecl *classDecl,
-    clang::BinaryOperatorKind operatorKind) {
+static clang::FunctionDecl *
+instantiateTemplatedOperator(ClangImporter::Implementation &impl,
+                             const clang::CXXRecordDecl *classDecl,
+                             clang::BinaryOperatorKind operatorKind) {
 
   clang::ASTContext &clangCtx = impl.getClangASTContext();
   clang::Sema &clangSema = impl.getClangSema();
@@ -252,6 +253,7 @@ static void instantiateTemplatedOperator(
     if (auto clangCallee = best->Function) {
       auto lookupTable = impl.findLookupTable(classDecl);
       addEntryToLookupTable(*lookupTable, clangCallee, impl.getNameImporter());
+      return clangCallee;
     }
     break;
   }
@@ -260,6 +262,82 @@ static void instantiateTemplatedOperator(
   case clang::OR_Deleted:
     break;
   }
+
+  return nullptr;
+}
+
+/// Warning: This function emits an error and stops compilation if the
+/// underlying operator function is unavailable in Swift for the current target
+/// (see `clang::Sema::DiagnoseAvailabilityOfDecl`).
+static bool makeOperatorFunc(ClangImporter::Implementation &impl,
+                             const clang::CXXRecordDecl *classDecl,
+                             clang::BinaryOperatorKind operatorKind) {
+  auto &clangCtx = impl.getClangASTContext();
+  auto &clangSema = impl.getClangSema();
+  auto classTy = clangCtx.getRecordType(classDecl);
+  auto classTyInfo = clangCtx.getTrivialTypeSourceInfo(classTy);
+
+  clang::OverloadedOperatorKind opKind =
+      clang::BinaryOperator::getOverloadedOperator(operatorKind);
+  const char *opSpelling = clang::getOperatorSpelling(opKind);
+
+  auto declName = clang::DeclarationName(&clangCtx.Idents.get(opSpelling));
+  auto declContext =
+      const_cast<clang::CXXRecordDecl *>(classDecl)->getDeclContext();
+  auto equalEqualTy =
+      clangCtx.getFunctionType(clangCtx.BoolTy, {classTy, classTy},
+                               clang::FunctionProtoType::ExtProtoInfo());
+
+  // Create a `bool operator==(T, T)` function.
+  auto equalEqualDecl = clang::FunctionDecl::Create(
+      clangCtx, declContext, clang::SourceLocation(), clang::SourceLocation(),
+      declName, equalEqualTy,
+      clangCtx.getTrivialTypeSourceInfo(clangCtx.BoolTy),
+      clang::StorageClass::SC_Static);
+  equalEqualDecl->setImplicit();
+  equalEqualDecl->setImplicitlyInline();
+  equalEqualDecl->setAccess(clang::AccessSpecifier::AS_public);
+
+  // Create the parameters of the function. They are not referenced from source
+  // code, so they don't need to have a name.
+  auto lhsParamId = nullptr;
+  auto lhsParamDecl = clang::ParmVarDecl::Create(
+      clangCtx, equalEqualDecl, clang::SourceLocation(),
+      clang::SourceLocation(), lhsParamId, classTy, classTyInfo,
+      clang::StorageClass::SC_None, /*DefArg*/ nullptr);
+  auto lhsParamRefExpr = new (clangCtx) clang::DeclRefExpr(
+      clangCtx, lhsParamDecl, false, classTy, clang::ExprValueKind::VK_LValue,
+      clang::SourceLocation());
+
+  auto rhsParamId = nullptr;
+  auto rhsParamDecl = clang::ParmVarDecl::Create(
+      clangCtx, equalEqualDecl, clang::SourceLocation(),
+      clang::SourceLocation(), rhsParamId, classTy, classTyInfo,
+      clang::StorageClass::SC_None, nullptr);
+  auto rhsParamRefExpr = new (clangCtx) clang::DeclRefExpr(
+      clangCtx, rhsParamDecl, false, classTy, clang::ExprValueKind::VK_LValue,
+      clang::SourceLocation());
+
+  equalEqualDecl->setParams({lhsParamDecl, rhsParamDecl});
+
+  // Lookup the `operator==` function that will be called under the hood.
+  clang::UnresolvedSet<16> operators;
+  // Note: calling `CreateOverloadedBinOp` emits an error if the looked up
+  // function is unavailable for the current target.
+  auto underlyingCallResult = clangSema.CreateOverloadedBinOp(
+      clang::SourceLocation(), operatorKind, operators, lhsParamRefExpr,
+      rhsParamRefExpr);
+  if (!underlyingCallResult.isUsable())
+    return false;
+  auto underlyingCall = underlyingCallResult.get();
+
+  auto equalEqualBody = clang::ReturnStmt::Create(
+      clangCtx, clang::SourceLocation(), underlyingCall, nullptr);
+  equalEqualDecl->setBody(equalEqualBody);
+
+  auto lookupTable = impl.findLookupTable(classDecl);
+  addEntryToLookupTable(*lookupTable, equalEqualDecl, impl.getNameImporter());
+  return true;
 }
 
 bool swift::isIterator(const clang::CXXRecordDecl *clangDecl) {
@@ -349,15 +427,26 @@ void swift::conformToCxxIteratorIfNeeded(
   if (!successorTy || successorTy->getAnyNominal() != decl)
     return;
 
-  // If this is a templated class, `operator==` might be templated as well.
-  // Try to instantiate it.
-  if (auto templateSpec =
-          dyn_cast<clang::ClassTemplateSpecializationDecl>(clangDecl)) {
-    instantiateTemplatedOperator(impl, templateSpec,
-                                 clang::BinaryOperatorKind::BO_EQ);
-  }
   // Check if present: `func ==`
   auto equalEqual = getEqualEqualOperator(decl);
+  if (!equalEqual) {
+    // If this class is inherited, `operator==` might be defined for a base
+    // class. If this is a templated class, `operator==` might be templated as
+    // well. Try to instantiate it.
+    clang::FunctionDecl* instantiated = instantiateTemplatedOperator(
+        impl, clangDecl, clang::BinaryOperatorKind::BO_EQ);
+    if (instantiated && !impl.isUnavailableInSwift(instantiated)) {
+      // If `operator==` was instantiated successfully, try to find `func ==`
+      // again.
+      equalEqual = getEqualEqualOperator(decl);
+      if (!equalEqual) {
+        // If `func ==` still can't be found, it might be defined for a base
+        // class of the current class.
+        makeOperatorFunc(impl, clangDecl, clang::BinaryOperatorKind::BO_EQ);
+        equalEqual = getEqualEqualOperator(decl);
+      }
+    }
+  }
   if (!equalEqual)
     return;
 
@@ -371,12 +460,19 @@ void swift::conformToCxxIteratorIfNeeded(
 
   // Try to conform to UnsafeCxxRandomAccessIterator if possible.
 
-  if (auto templateSpec =
-          dyn_cast<clang::ClassTemplateSpecializationDecl>(clangDecl)) {
-    instantiateTemplatedOperator(impl, templateSpec,
-                                 clang::BinaryOperatorKind::BO_Sub);
+  // Check if present: `func -`
+  auto minus = getMinusOperator(decl);
+  if (!minus) {
+    clang::FunctionDecl *instantiated = instantiateTemplatedOperator(
+        impl, clangDecl, clang::BinaryOperatorKind::BO_Sub);
+    if (instantiated && !impl.isUnavailableInSwift(instantiated)) {
+      minus = getMinusOperator(decl);
+      if (!minus) {
+        makeOperatorFunc(impl, clangDecl, clang::BinaryOperatorKind::BO_Sub);
+        minus = getMinusOperator(decl);
+      }
+    }
   }
-  auto minus = dyn_cast_or_null<FuncDecl>(getMinusOperator(decl));
   if (!minus)
     return;
   auto distanceTy = minus->getResultInterfaceType();

lib/ClangImporter/ClangImporter.cpp

@@ -2787,6 +2787,8 @@ getClangOwningModule(ClangNode Node, const clang::ASTContext &ClangCtx) {
         // Let's use the owning module of the template pattern.
         originalDecl = pattern;
       }
+      if (functionDecl->isImplicit()) {
+      }
     }
 
     return ExtSource->getModule(originalDecl->getOwningModuleID());
@@ -2841,6 +2843,8 @@ static bool isVisibleFromModule(const ClangModuleUnit *ModuleFilter,
                                                         ClangASTContext);
   if (OwningClangModule == ModuleFilter->getClangModule())
     return true;
+  if (!OwningClangModule && D->isImplicit())
+    return true;
 
   // Friends from class templates don't have an owning module. Just return true.
   if (isa<clang::FunctionDecl>(D) &&

test/Interop/Cxx/stdlib/overlay/Inputs/custom-collection.h

@@ -28,4 +28,21 @@ struct SimpleCollectionReadOnly {
   const int& operator[](int index) const { return x[index]; }
 };
 
+template <typename T>
+struct HasInheritedTemplatedConstRACIterator {
+public:
+  typedef InheritedTemplatedConstRACIterator<int> iterator;
+
+private:
+  iterator b = iterator(1);
+  iterator e = iterator(6);
+
+public:
+  iterator begin() const { return b; }
+  iterator end() const { return e; }
+};
+
+typedef HasInheritedTemplatedConstRACIterator<int>
+    HasInheritedTemplatedConstRACIteratorInt;
+
 #endif // TEST_INTEROP_CXX_STDLIB_INPUTS_CUSTOM_COLLECTION_H