Merge pull request #60001 from apple/egorzhdan/synthesize-iterator-conformance

[cxx-interop] Synthesize conformances to `UnsafeCxxInputIterator`

Author: egorzhdan

include/swift/AST/KnownIdentifiers.def

@@ -59,6 +59,7 @@ IDENTIFIER(CGFloat)
 IDENTIFIER(CoreFoundation)
 IDENTIFIER(count)
 IDENTIFIER(CVarArg)
+IDENTIFIER(Cxx)
 IDENTIFIER(Darwin)
 IDENTIFIER(Distributed)
 IDENTIFIER(dealloc)

include/swift/AST/KnownProtocols.def

@@ -104,6 +104,9 @@ PROTOCOL(DistributedTargetInvocationEncoder)
 PROTOCOL(DistributedTargetInvocationDecoder)
 PROTOCOL(DistributedTargetInvocationResultHandler)
 
+// C++ Standard Library Overlay:
+PROTOCOL(UnsafeCxxInputIterator)
+
 PROTOCOL(AsyncSequence)
 PROTOCOL(AsyncIteratorProtocol)
 

lib/AST/ASTContext.cpp

@@ -1044,6 +1044,9 @@ ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
   case KnownProtocolKind::DistributedTargetInvocationResultHandler:
     M = getLoadedModule(Id_Distributed);
     break;
+  case KnownProtocolKind::UnsafeCxxInputIterator:
+    M = getLoadedModule(Id_Cxx);
+    break;
   default:
     M = getStdlibModule();
     break;

lib/ClangImporter/CMakeLists.txt

@@ -8,6 +8,7 @@ add_gyb_target(generated_sorted_cf_database
 add_swift_host_library(swiftClangImporter STATIC
   CFTypeInfo.cpp
   ClangAdapter.cpp
+  ClangDerivedConformances.cpp
   ClangDiagnosticConsumer.cpp
   ClangImporter.cpp
   ClangImporterRequests.cpp

lib/ClangImporter/ClangDerivedConformances.cpp

@@ -0,0 +1,130 @@
+//===--- ClangDerivedConformances.cpp -------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#include "ClangDerivedConformances.h"
+#include "swift/AST/NameLookup.h"
+#include "swift/AST/ParameterList.h"
+
+using namespace swift;
+
+static clang::TypeDecl *
+getIteratorCategoryDecl(const clang::CXXRecordDecl *clangDecl) {
+  clang::IdentifierInfo *iteratorCategoryDeclName =
+      &clangDecl->getASTContext().Idents.get("iterator_category");
+  auto iteratorCategories = clangDecl->lookup(iteratorCategoryDeclName);
+  if (!iteratorCategories.isSingleResult())
+    return nullptr;
+  auto iteratorCategory = iteratorCategories.front();
+
+  return dyn_cast_or_null<clang::TypeDecl>(iteratorCategory);
+}
+
+bool swift::isIterator(const clang::CXXRecordDecl *clangDecl) {
+  return getIteratorCategoryDecl(clangDecl);
+}
+
+void swift::conformToCxxIteratorIfNeeded(
+    ClangImporter::Implementation &impl, NominalTypeDecl *decl,
+    const clang::CXXRecordDecl *clangDecl) {
+  assert(decl);
+  assert(clangDecl);
+  ASTContext &ctx = decl->getASTContext();
+
+  // We consider a type to be an input iterator if it defines an
+  // `iterator_category` that inherits from `std::input_iterator_tag`, e.g.
+  // `using iterator_category = std::input_iterator_tag`.
+  auto iteratorCategory = getIteratorCategoryDecl(clangDecl);
+  if (!iteratorCategory)
+    return;
+
+  // If `iterator_category` is a typedef or a using-decl, retrieve the
+  // underlying struct decl.
+  clang::CXXRecordDecl *underlyingCategoryDecl = nullptr;
+  if (auto typedefDecl = dyn_cast<clang::TypedefNameDecl>(iteratorCategory)) {
+    auto type = typedefDecl->getUnderlyingType();
+    underlyingCategoryDecl = type->getAsCXXRecordDecl();
+  } else {
+    underlyingCategoryDecl = dyn_cast<clang::CXXRecordDecl>(iteratorCategory);
+  }
+  if (underlyingCategoryDecl) {
+    underlyingCategoryDecl = underlyingCategoryDecl->getDefinition();
+  }
+
+  if (!underlyingCategoryDecl)
+    return;
+
+  auto isInputIteratorDecl = [&](const clang::CXXRecordDecl *base) {
+    return base->isInStdNamespace() && base->getIdentifier() &&
+           base->getName() == "input_iterator_tag";
+  };
+
+  // Traverse all transitive bases of `underlyingDecl` to check if
+  // it inherits from `std::input_iterator_tag`.
+  bool isInputIterator = isInputIteratorDecl(underlyingCategoryDecl);
+  underlyingCategoryDecl->forallBases([&](const clang::CXXRecordDecl *base) {
+    if (isInputIteratorDecl(base)) {
+      isInputIterator = true;
+      return false;
+    }
+    return true;
+  });
+
+  if (!isInputIterator)
+    return;
+
+  // Check if present: `var pointee: Pointee { get }`
+  auto pointeeId = ctx.getIdentifier("pointee");
+  auto pointees = decl->lookupDirect(pointeeId);
+  if (pointees.size() != 1)
+    return;
+  auto pointee = dyn_cast<VarDecl>(pointees.front());
+  if (!pointee || pointee->isGetterMutating())
+    return;
+
+  // Check if present: `func successor() -> Self`
+  auto successorId = ctx.getIdentifier("successor");
+  auto successors = decl->lookupDirect(successorId);
+  if (successors.size() != 1)
+    return;
+  auto successor = dyn_cast<FuncDecl>(successors.front());
+  if (!successor || successor->isMutating())
+    return;
+  auto successorTy = successor->getResultInterfaceType();
+  if (!successorTy || successorTy->getAnyNominal() != decl)
+    return;
+
+  // Check if present: `func ==`
+  // FIXME: this only detects `operator==` declared as a member.
+  auto equalEquals = decl->lookupDirect(ctx.Id_EqualsOperator);
+  if (equalEquals.empty())
+    return;
+  auto equalEqual = dyn_cast<FuncDecl>(equalEquals.front());
+  if (!equalEqual || !equalEqual->hasParameterList())
+    return;
+  auto equalEqualParams = equalEqual->getParameters();
+  if (equalEqualParams->size() != 2)
+    return;
+  auto equalEqualLHS = equalEqualParams->get(0);
+  auto equalEqualRHS = equalEqualParams->get(1);
+  if (equalEqualLHS->isInOut() || equalEqualRHS->isInOut())
+    return;
+  auto equalEqualLHSTy = equalEqualLHS->getType();
+  auto equalEqualRHSTy = equalEqualRHS->getType();
+  if (!equalEqualLHSTy || !equalEqualRHSTy ||
+      equalEqualLHSTy->getAnyNominal() != equalEqualRHSTy->getAnyNominal())
+    return;
+
+  impl.addSynthesizedTypealias(decl, ctx.getIdentifier("Pointee"),
+                               pointee->getType());
+  impl.addSynthesizedProtocolAttrs(decl,
+                                   {KnownProtocolKind::UnsafeCxxInputIterator});
+}

lib/ClangImporter/ClangDerivedConformances.h

@@ -0,0 +1,31 @@
+//===--- ClangDerivedConformances.h -----------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_CLANG_DERIVED_CONFORMANCES_H
+#define SWIFT_CLANG_DERIVED_CONFORMANCES_H
+
+#include "ImporterImpl.h"
+#include "swift/AST/ASTContext.h"
+
+namespace swift {
+
+bool isIterator(const clang::CXXRecordDecl *clangDecl);
+
+/// If the decl is a C++ input iterator, synthesize a conformance to the
+/// UnsafeCxxInputIterator protocol, which is defined in the std overlay.
+void conformToCxxIteratorIfNeeded(ClangImporter::Implementation &impl,
+                                  NominalTypeDecl *decl,
+                                  const clang::CXXRecordDecl *clangDecl);
+
+} // namespace swift
+
+#endif // SWIFT_CLANG_DERIVED_CONFORMANCES_H

lib/ClangImporter/ClangImporter.cpp

@@ -14,6 +14,7 @@
 //
 //===----------------------------------------------------------------------===//
 #include "swift/ClangImporter/ClangImporter.h"
+#include "ClangDerivedConformances.h"
 #include "ClangDiagnosticConsumer.h"
 #include "ClangIncludePaths.h"
 #include "ImporterImpl.h"
@@ -3232,6 +3233,19 @@ static void getImportDecls(ClangModuleUnit *ClangUnit, const clang::Module *M,
     auto *ID = createImportDecl(Ctx, ClangUnit, ImportedMod, Exported);
     Results.push_back(ID);
   }
+
+  if (Ctx.LangOpts.EnableCXXInterop && requiresCPlusPlus(M)) {
+    // Try to load the Cxx module. We don't use it directly here, but we need to
+    // make sure that ASTContext has loaded this module.
+    auto *cxxModule = Ctx.getModuleByIdentifier(Ctx.Id_Cxx);
+    if (cxxModule) {
+      ImportPath::Builder builder(Ctx.Id_Cxx);
+      auto *importCxx =
+          ImportDecl::create(Ctx, ClangUnit, SourceLoc(), ImportKind::Module,
+                             SourceLoc(), builder.get());
+      Results.push_back(importCxx);
+    }
+  }
 }
 
 void ClangModuleUnit::getDisplayDecls(SmallVectorImpl<Decl*> &results, bool recursive) const {
@@ -5962,7 +5976,7 @@ CxxRecordSemantics::evaluate(Evaluator &evaluator,
     return CxxRecordSemanticsKind::Owned;
   }
 
-  if (hasIteratorAPIAttr(decl)) {
+  if (hasIteratorAPIAttr(decl) || isIterator(decl)) {
     return CxxRecordSemanticsKind::Iterator;
   }
 

lib/ClangImporter/ImportDecl.cpp

@@ -16,6 +16,7 @@
 
 #include "CFTypeInfo.h"
 #include "ImporterImpl.h"
+#include "ClangDerivedConformances.h"
 #include "SwiftDeclSynthesizer.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Attr.h"
@@ -2499,7 +2500,18 @@ namespace {
         return nullptr;
       }
 
-      return VisitRecordDecl(decl);
+      auto result = VisitRecordDecl(decl);
+
+      // If this module is declared as a C++ module, try to synthesize
+      // conformances to Swift protocols from the Cxx module.
+      auto clangModule = decl->getOwningModule();
+      if (clangModule && requiresCPlusPlus(clangModule)) {
+        if (auto structDecl = dyn_cast_or_null<NominalTypeDecl>(result)) {
+          conformToCxxIteratorIfNeeded(Impl, structDecl, decl);
+        }
+      }
+
+      return result;
     }
 
     bool isSpecializationDepthGreaterThan(

lib/ClangImporter/ImporterImpl.h

@@ -1861,6 +1861,22 @@ inline Optional<const clang::EnumDecl *> findAnonymousEnumForTypedef(
   return None;
 }
 
+inline bool requiresCPlusPlus(const clang::Module *module) {
+  // The libc++ modulemap doesn't currently declare the requirement.
+  if (module->getTopLevelModuleName() == "std")
+    return true;
+
+  // Modulemaps often declare the requirement for the top-level module only.
+  if (auto parent = module->Parent) {
+    if (requiresCPlusPlus(parent))
+      return true;
+  }
+
+  return llvm::any_of(module->Requirements, [](clang::Module::Requirement req) {
+    return req.first == "cplusplus";
+  });
+}
+
 }
 }
 

lib/IRGen/GenMeta.cpp

@@ -5778,6 +5778,7 @@ SpecialProtocol irgen::getSpecialProtocolID(ProtocolDecl *P) {
   case KnownProtocolKind::DistributedTargetInvocationEncoder:
   case KnownProtocolKind::DistributedTargetInvocationDecoder:
   case KnownProtocolKind::DistributedTargetInvocationResultHandler:
+  case KnownProtocolKind::UnsafeCxxInputIterator:
   case KnownProtocolKind::SerialExecutor:
   case KnownProtocolKind::Sendable:
   case KnownProtocolKind::UnsafeSendable: