[cxx-interop] Allow Swift extensions to access non-public C++ members

include/swift/AST/ClangModuleLoader.h

@@ -204,8 +204,10 @@ class ClangModuleLoader : public ModuleLoader {
 
   /// Imports a clang decl from a base class, cloning it for \param newContext
   /// if it wasn't cloned for this specific context before.
-  virtual ValueDecl *importBaseMemberDecl(ValueDecl *decl,
-                                          DeclContext *newContext) = 0;
+  virtual ValueDecl *
+  importBaseMemberDecl(ValueDecl *decl,
+                       DeclContext *newContext,
+                       clang::AccessSpecifier inheritance) = 0;
 
   /// Emits diagnostics for any declarations named name
   /// whose direct declaration context is a TU.

include/swift/AST/Decl.h

@@ -2778,6 +2778,10 @@ class ValueDecl : public Decl {
 
     /// Whether we've evaluated the ApplyAccessNoteRequest.
     unsigned accessNoteApplied : 1;
+
+    /// Whether this declaration represents an inherited C++ member that is
+    /// lazily cloned from a base class.
+    unsigned isLazilyInheritedClone : 1;
   } LazySemanticInfo = { };
 
   friend class DynamicallyReplacedDeclRequest;
@@ -3181,6 +3185,17 @@ class ValueDecl : public Decl {
     LazySemanticInfo.isIUO = isIUO;
   }
 
+  /// Returns true if this decl represents an inherited C++ member that is
+  /// lazily cloned from a base class.
+  bool isLazilyInheritedClone() const {
+    return LazySemanticInfo.isLazilyInheritedClone;
+  }
+
+  /// Marks this decl as representing an inherited C++ member.
+  void setLazilyInheritedClone(bool isLazilyInheritedClone) {
+    LazySemanticInfo.isLazilyInheritedClone = isLazilyInheritedClone;
+  }
+
   /// Returns the protocol requirements that this decl conforms to.
   ArrayRef<ValueDecl *>
   getSatisfiedProtocolRequirements(bool Sorted = false) const;

include/swift/AST/DiagnosticsClangImporter.def

@@ -208,6 +208,23 @@ NOTE(iterator_method_unavailable, none, "C++ method '%0' that returns an "
 NOTE(iterator_potentially_unsafe, none, "C++ methods that return iterators "
                                         "are potentially unsafe; try using Swift collection APIs instead", ())
 
+ERROR(private_fileid_attr_repeated, none,
+    "multiple SWIFT_PRIVATE_FILEID annotations were found on '%0'",
+    (StringRef))
+ERROR(private_fileid_attr_on_incomplete_type, none,
+    "SWIFT_PRIVATE_FILEID cannot be applied to incomplete type, '%0'",
+    (StringRef))
+NOTE(private_fileid_attr_here, none,
+    "SWIFT_PRIVATE_FILEID annotation found here", ())
+
+WARNING(private_fileid_attr_format_invalid, none,
+    "SWIFT_PRIVATE_FILEID annotation on '%0' does not have a valid file ID",
+    (StringRef))
+REMARK(private_fileid_attr_format_specification, none,
+    "file IDs have the following format: 'ModuleName/FileName.swift'", ())
+NOTE(private_fileid_attr_format_suggestion, none,
+    "did you mean '%0'?", (StringRef))
+
 ERROR(reference_type_must_have_retain_release_attr, none,
       "reference type '%1' must have %select{'retain:'|'release:'}0 Swift "
       "attribute",

include/swift/AST/SourceFile.h

@@ -653,6 +653,14 @@ class SourceFile final : public FileUnit {
     Scope = nullptr;
   }
 
+  /// Whether the given string matches the file ID of this file.
+  bool matchesFileID(StringRef fileID) const;
+
+  /// Parses a file ID string into the module name and file name (with ".swift"
+  /// suffix). Returns nullopt if the file ID string is invalid.
+  static std::optional<std::pair<StringRef, StringRef>>
+  parseFileID(StringRef fileID);
+
   /// Retrieves the previously set delayed parser state, asserting that it
   /// exists.
   PersistentParserState *getDelayedParserState() {

include/swift/ClangImporter/ClangImporter.h

@@ -16,7 +16,9 @@
 #ifndef SWIFT_CLANG_IMPORTER_H
 #define SWIFT_CLANG_IMPORTER_H
 
+#include "swift/AST/AttrKind.h"
 #include "swift/AST/ClangModuleLoader.h"
+#include "clang/Basic/Specifiers.h"
 #include "llvm/Support/VirtualFileSystem.h"
 
 /// The maximum number of SIMD vector elements we currently try to import.
@@ -656,7 +658,8 @@ class ClangImporter final : public ClangModuleLoader {
   Decl *importDeclDirectly(const clang::NamedDecl *decl) override;
 
   ValueDecl *importBaseMemberDecl(ValueDecl *decl,
-                                  DeclContext *newContext) override;
+                                  DeclContext *newContext,
+                                  clang::AccessSpecifier inheritance) override;
 
   /// Emits diagnostics for any declarations named name
   /// whose direct declaration context is a TU.
@@ -729,6 +732,19 @@ ValueDecl *getImportedMemberOperator(const DeclBaseName &name,
                                      NominalTypeDecl *selfType,
                                      std::optional<Type> parameterType);
 
+/// Read file IDs from 'private_fileid' Swift attributes on a Clang decl.
+///
+/// May return >1 fileID when a decl is annotated more than once, which should
+/// be treated as an error and appropriately diagnosed (using the included
+/// SourceLocation).
+SmallVector<std::pair<StringRef, clang::SourceLocation>, 1>
+getPrivateFileIDAttrs(const clang::Decl *decl);
+
+/// Map the access specifier of a Clang record member to a Swift access level.
+///
+/// This mapping is conservative: the resulting Swift access should be at _most_
+/// as permissive as the input C++ access.
+AccessLevel convertClangAccess(clang::AccessSpecifier access);
 } // namespace importer
 
 struct ClangInvocationFileMapping {

include/swift/ClangImporter/ClangImporterRequests.h

@@ -23,6 +23,7 @@
 #include "swift/AST/SimpleRequest.h"
 #include "swift/Basic/Statistic.h"
 #include "clang/AST/Type.h"
+#include "clang/Basic/Specifiers.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/TinyPtrVector.h"
 
@@ -125,29 +126,46 @@ class CXXNamespaceMemberLookup
 private:
   friend SimpleRequest;
 
-  // Evaluation.
   TinyPtrVector<ValueDecl *>
   evaluate(Evaluator &evaluator, CXXNamespaceMemberLookupDescriptor desc) const;
 };
 
 /// The input type for a record member lookup request.
+///
+/// These lookups may be requested recursively in the case of inheritance,
+/// for which we separately keep track of the derived class where we started
+/// looking (startDecl) and the access level for the current inheritance.
 struct ClangRecordMemberLookupDescriptor final {
-  NominalTypeDecl *recordDecl;
-  DeclName name;
+  NominalTypeDecl *recordDecl;        // Where we are currently looking
+  NominalTypeDecl *startDecl;         // Where we started looking
+  DeclName name;                      // What we are looking for
+  clang::AccessSpecifier inheritance; // Public, protected, or private inheritance
+                                      // (clang::AS_none means no inheritance)
 
   ClangRecordMemberLookupDescriptor(NominalTypeDecl *recordDecl, DeclName name)
-      : recordDecl(recordDecl), name(name) {
+      : recordDecl(recordDecl), startDecl(recordDecl), name(name), inheritance(clang::AS_none) {
+    assert(isa<clang::RecordDecl>(recordDecl->getClangDecl()));
+  }
+
+  ClangRecordMemberLookupDescriptor(NominalTypeDecl *recordDecl, DeclName name,
+      clang::AccessSpecifier inheritance, NominalTypeDecl *startDecl)
+      : recordDecl(recordDecl), startDecl(startDecl), name(name), inheritance(inheritance) {
     assert(isa<clang::RecordDecl>(recordDecl->getClangDecl()));
+    assert(isa<clang::RecordDecl>(startDecl->getClangDecl()));
+    assert(inheritance != clang::AS_none && "recursive member lookup should use non-none inheritance");
   }
 
+public:
+  friend class ClangRecordMemberLookup;
+
   friend llvm::hash_code
   hash_value(const ClangRecordMemberLookupDescriptor &desc) {
-    return llvm::hash_combine(desc.name, desc.recordDecl);
+    return llvm::hash_combine(desc.name, desc.recordDecl, desc.inheritance);
   }
 
   friend bool operator==(const ClangRecordMemberLookupDescriptor &lhs,
                          const ClangRecordMemberLookupDescriptor &rhs) {
-    return lhs.name == rhs.name && lhs.recordDecl == rhs.recordDecl;
+    return lhs.name == rhs.name && lhs.recordDecl == rhs.recordDecl && lhs.inheritance == rhs.inheritance;
   }
 
   friend bool operator!=(const ClangRecordMemberLookupDescriptor &lhs,

lib/AST/ASTMangler.cpp

@@ -41,6 +41,7 @@
 #include "swift/Basic/Defer.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/ClangImporter/ClangImporter.h"
+#include "swift/ClangImporter/ClangModule.h"
 #include "swift/Demangling/Demangler.h"
 #include "swift/Demangling/ManglingMacros.h"
 #include "swift/Demangling/ManglingUtils.h"
@@ -53,8 +54,8 @@
 #include "clang/AST/Mangle.h"
 #include "clang/Basic/CharInfo.h"
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -1016,6 +1017,11 @@ static StringRef getPrivateDiscriminatorIfNecessary(const Decl *decl) {
   auto topLevelSubcontext = decl->getDeclContext()->getModuleScopeContext();
   auto fileUnit = cast<FileUnit>(topLevelSubcontext);
 
+  // Clang modules do not provide a namespace, so no discriminator is needed
+  // here, even for non-public declarations.
+  if (isa<ClangModuleUnit>(fileUnit))
+    return StringRef();
+
   Identifier discriminator =
       fileUnit->getDiscriminatorForPrivateDecl(decl);
   assert(!discriminator.empty());

lib/AST/DeclContext.cpp

@@ -11,9 +11,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/AST/DeclContext.h"
-#include "swift/AST/AccessScope.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTWalker.h"
+#include "swift/AST/AccessScope.h"
 #include "swift/AST/ClangModuleLoader.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/FileUnit.h"
@@ -23,16 +23,17 @@
 #include "swift/AST/Module.h"
 #include "swift/AST/ParseRequests.h"
 #include "swift/AST/SourceFile.h"
-#include "swift/AST/Types.h"
 #include "swift/AST/TypeCheckRequests.h"
+#include "swift/AST/Types.h"
 #include "swift/Basic/Assertions.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Basic/Statistic.h"
+#include "swift/ClangImporter/ClangImporter.h"
+#include "clang/AST/ASTContext.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Statistic.h"
-#include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/SaveAndRestore.h"
-#include "clang/AST/ASTContext.h"
+#include "llvm/Support/raw_ostream.h"
 using namespace swift;
 
 #define DEBUG_TYPE "Name lookup"
@@ -1298,16 +1299,28 @@ bool AccessScope::allowsPrivateAccess(const DeclContext *useDC, const DeclContex
       return usePkg->isSamePackageAs(srcPkg);
     }
   }
-  // Do not allow access if the sourceDC is in a different file
-  auto useSF = useDC->getOutermostParentSourceFile();
-  if (useSF != sourceDC->getOutermostParentSourceFile())
-    return false;
 
   // Do not allow access if the sourceDC does not represent a type.
   auto sourceNTD = sourceDC->getSelfNominalTypeDecl();
   if (!sourceNTD)
     return false;
 
+  // Do not allow access if the sourceDC is in a different file
+  auto useSF = useDC->getOutermostParentSourceFile();
+  if (useSF != sourceDC->getOutermostParentSourceFile()) {
+    // This might be a C++ declaration with a SWIFT_IMPLEMENTATION_FILEID
+    // attribute, which asks us to treat it as if it were defined in the file
+    // with the specified FileID.
+    bool blessedUseSF = false;
+    if (auto clangDecl = sourceNTD->getDecl()->getClangDecl()) {
+      auto blessedFileID = importer::getPrivateFileIDAttrs(clangDecl);
+      if (!blessedFileID.empty())
+        blessedUseSF = useSF->matchesFileID(blessedFileID[0].first);
+    }
+    if (!blessedUseSF)
+      return false;
+  }
+
   // Compare the private scopes and iterate over the parent types.
   sourceDC = getPrivateDeclContext(sourceDC, useSF);
   while (!useDC->isModuleContext()) {

lib/AST/Module.cpp

@@ -3614,6 +3614,32 @@ ASTScope &SourceFile::getScope() {
   return *Scope.get();
 }
 
+bool SourceFile::matchesFileID(StringRef fileID) const {
+  // Never match with SourceFiles that do not correpond to a file on disk
+  if (getFilename().empty())
+    return false;
+
+  auto parsed = parseFileID(fileID);
+  if (!parsed)
+    return false;
+
+  auto moduleName = parsed->first;
+  auto fileName = parsed->second;
+
+  return moduleName == getParentModule()->getNameStr() &&
+         fileName == llvm::sys::path::filename(getFilename());
+}
+
+std::optional<std::pair<StringRef, StringRef>>
+SourceFile::parseFileID(StringRef fileID) {
+  auto names = fileID.split('/');
+  auto moduleName = names.first;
+  auto fileName = names.second;
+  if (moduleName.empty() || fileName.empty() || !fileName.ends_with(".swift"))
+    return {};
+  return {{moduleName, fileName}};
+}
+
 Identifier SourceFile::getPrivateDiscriminator(bool createIfMissing) const {
   if (!PrivateDiscriminator.empty() || !createIfMissing)
     return PrivateDiscriminator;