Merge pull request #74783 from susmonteiro/susmonteiro/cxx-span-from-ubpointer

[cxx-interop] Implements constructor for std::span from UnsafeBufferPointer

Author: susmonteiro

include/swift/AST/KnownProtocols.def

@@ -135,6 +135,7 @@ PROTOCOL(CxxRandomAccessCollection)
 PROTOCOL(CxxSequence)
 PROTOCOL(CxxUniqueSet)
 PROTOCOL(CxxVector)
+PROTOCOL(CxxSpan)
 PROTOCOL(UnsafeCxxInputIterator)
 PROTOCOL(UnsafeCxxMutableInputIterator)
 PROTOCOL(UnsafeCxxRandomAccessIterator)

lib/AST/ASTContext.cpp

@@ -1341,6 +1341,7 @@ ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
   case KnownProtocolKind::CxxSequence:
   case KnownProtocolKind::CxxUniqueSet:
   case KnownProtocolKind::CxxVector:
+  case KnownProtocolKind::CxxSpan:
   case KnownProtocolKind::UnsafeCxxInputIterator:
   case KnownProtocolKind::UnsafeCxxMutableInputIterator:
   case KnownProtocolKind::UnsafeCxxRandomAccessIterator:

lib/ClangImporter/ClangDerivedConformances.cpp

@@ -122,6 +122,22 @@ static bool isStdDecl(const clang::CXXRecordDecl *clangDecl,
   return llvm::is_contained(names, name);
 }
 
+static clang::TypeDecl *
+lookupNestedClangTypeDecl(const clang::CXXRecordDecl *clangDecl,
+                          StringRef name) {
+  clang::IdentifierInfo *nestedDeclName =
+      &clangDecl->getASTContext().Idents.get(name);
+  auto nestedDecls = clangDecl->lookup(nestedDeclName);
+  // If this is a templated typedef, Clang might have instantiated several
+  // equivalent typedef decls. If they aren't equivalent, Clang has already
+  // complained about this. Let's assume that they are equivalent. (see
+  // filterNonConflictingPreviousTypedefDecls in clang/Sema/SemaDecl.cpp)
+  if (nestedDecls.empty())
+    return nullptr;
+  auto nestedDecl = nestedDecls.front();
+  return dyn_cast_or_null<clang::TypeDecl>(nestedDecl);
+}
+
 static clang::TypeDecl *
 getIteratorCategoryDecl(const clang::CXXRecordDecl *clangDecl) {
   clang::IdentifierInfo *iteratorCategoryDeclName =
@@ -1128,4 +1144,94 @@ void swift::conformToCxxFunctionIfNeeded(
   decl->addMember(importedConstructor);
 
   // TODO: actually conform to some form of CxxFunction protocol
+
+}
+
+void swift::conformToCxxSpanIfNeeded(ClangImporter::Implementation &impl,
+                                     NominalTypeDecl *decl,
+                                     const clang::CXXRecordDecl *clangDecl) {
+  PrettyStackTraceDecl trace("conforming to CxxSpan", decl);
+
+  assert(decl);
+  assert(clangDecl);
+  ASTContext &ctx = decl->getASTContext();
+  clang::ASTContext &clangCtx = impl.getClangASTContext();
+  clang::Sema &clangSema = impl.getClangSema();
+
+  // Only auto-conform types from the C++ standard library. Custom user types
+  // might have a similar interface but different semantics.
+  if (!isStdDecl(clangDecl, {"span"}))
+    return;
+
+  auto elementType = lookupDirectSingleWithoutExtensions<TypeAliasDecl>(
+      decl, ctx.getIdentifier("element_type"));
+  auto sizeType = lookupDirectSingleWithoutExtensions<TypeAliasDecl>(
+      decl, ctx.getIdentifier("size_type"));
+
+  if (!elementType || !sizeType)
+    return;
+
+  auto constPointerTypeDecl =
+      lookupNestedClangTypeDecl(clangDecl, "const_pointer");
+  auto countTypeDecl = lookupNestedClangTypeDecl(clangDecl, "size_type");
+
+  if (!constPointerTypeDecl || !countTypeDecl)
+    return;
+
+  // create fake variable for constPointer (constructor arg 1)
+  auto constPointerType = clangCtx.getTypeDeclType(constPointerTypeDecl);
+  auto fakeConstPointerVarDecl = clang::VarDecl::Create(
+      clangCtx, /*DC*/ clangCtx.getTranslationUnitDecl(),
+      clang::SourceLocation(), clang::SourceLocation(), /*Id*/ nullptr,
+      constPointerType, clangCtx.getTrivialTypeSourceInfo(constPointerType),
+      clang::StorageClass::SC_None);
+
+  auto fakeConstPointer = new (clangCtx) clang::DeclRefExpr(
+      clangCtx, fakeConstPointerVarDecl, false, constPointerType,
+      clang::ExprValueKind::VK_LValue, clang::SourceLocation());
+
+  // create fake variable for count (constructor arg 2)
+  auto countType = clangCtx.getTypeDeclType(countTypeDecl);
+  auto fakeCountVarDecl = clang::VarDecl::Create(
+      clangCtx, /*DC*/ clangCtx.getTranslationUnitDecl(),
+      clang::SourceLocation(), clang::SourceLocation(), /*Id*/ nullptr,
+      countType, clangCtx.getTrivialTypeSourceInfo(countType),
+      clang::StorageClass::SC_None);
+
+  auto fakeCount = new (clangCtx) clang::DeclRefExpr(
+      clangCtx, fakeCountVarDecl, false, countType,
+      clang::ExprValueKind::VK_LValue, clang::SourceLocation());
+
+  // Use clangSema.BuildCxxTypeConstructExpr to create a CXXTypeConstructExpr,
+  // passing constPointer and count
+  SmallVector<clang::Expr *, 2> constructExprArgs = {fakeConstPointer,
+                                                     fakeCount};
+
+  auto clangDeclTyInfo = clangCtx.getTrivialTypeSourceInfo(
+      clang::QualType(clangDecl->getTypeForDecl(), 0));
+
+  // Instantiate the templated constructor that would accept this fake variable.
+  auto constructExprResult = clangSema.BuildCXXTypeConstructExpr(
+      clangDeclTyInfo, clangDecl->getLocation(), constructExprArgs,
+      clangDecl->getLocation(), /*ListInitialization*/ false);
+  if (!constructExprResult.isUsable())
+    return;
+
+  auto constructExpr =
+      dyn_cast_or_null<clang::CXXConstructExpr>(constructExprResult.get());
+  if (!constructExpr)
+    return;
+
+  auto constructorDecl = constructExpr->getConstructor();
+  auto importedConstructor =
+      impl.importDecl(constructorDecl, impl.CurrentVersion);
+  if (!importedConstructor)
+    return;
+  decl->addMember(importedConstructor);
+
+  impl.addSynthesizedTypealias(decl, ctx.Id_Element,
+                               elementType->getUnderlyingType());
+  impl.addSynthesizedTypealias(decl, ctx.getIdentifier("Size"),
+                               sizeType->getUnderlyingType());
+  impl.addSynthesizedProtocolAttrs(decl, {KnownProtocolKind::CxxSpan});
 }

lib/ClangImporter/ClangDerivedConformances.h

@@ -76,6 +76,12 @@ void conformToCxxVectorIfNeeded(ClangImporter::Implementation &impl,
 void conformToCxxFunctionIfNeeded(ClangImporter::Implementation &impl,
                                   NominalTypeDecl *decl,
                                   const clang::CXXRecordDecl *clangDecl);
+                                  
+/// If the decl is an instantiation of C++ `std::span`, synthesize a
+/// conformance to CxxSpan, which is defined in the Cxx module.
+void conformToCxxSpanIfNeeded(ClangImporter::Implementation &impl,
+                                NominalTypeDecl *decl,
+                                const clang::CXXRecordDecl *clangDecl);
 
 } // namespace swift
 

lib/ClangImporter/ImportDecl.cpp

@@ -2826,6 +2826,7 @@ namespace {
           conformToCxxOptionalIfNeeded(Impl, nominalDecl, decl);
           conformToCxxVectorIfNeeded(Impl, nominalDecl, decl);
           conformToCxxFunctionIfNeeded(Impl, nominalDecl, decl);
+          conformToCxxSpanIfNeeded(Impl, nominalDecl, decl);
         }
       }
 

lib/IRGen/GenMeta.cpp

@@ -6836,6 +6836,7 @@ SpecialProtocol irgen::getSpecialProtocolID(ProtocolDecl *P) {
   case KnownProtocolKind::CxxSequence:
   case KnownProtocolKind::CxxUniqueSet:
   case KnownProtocolKind::CxxVector:
+  case KnownProtocolKind::CxxSpan:
   case KnownProtocolKind::UnsafeCxxInputIterator:
   case KnownProtocolKind::UnsafeCxxMutableInputIterator:
   case KnownProtocolKind::UnsafeCxxRandomAccessIterator:

stdlib/public/Cxx/CMakeLists.txt

@@ -16,6 +16,7 @@ add_swift_target_library(swiftCxx STATIC NO_LINK_NAME IS_STDLIB IS_SWIFT_ONLY IS
     CxxRandomAccessCollection.swift
     CxxSequence.swift
     CxxVector.swift
+    CxxSpan.swift
     UnsafeCxxIterators.swift
 
     SWIFT_COMPILE_FLAGS ${SWIFT_RUNTIME_SWIFT_COMPILE_FLAGS} ${SWIFT_STANDARD_LIBRARY_SWIFT_FLAGS}

stdlib/public/Cxx/CxxSpan.swift

@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 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
+//
+//===----------------------------------------------------------------------===//
+
+/// A C++ type that is an object that can refer to a contiguous sequence of objects.
+///
+/// C++ standard library type `std::span` conforms to this protocol.
+public protocol CxxSpan<Element> {
+  associatedtype Element
+  associatedtype Size: BinaryInteger
+
+  init()
+  init(_ unsafePointer : UnsafePointer<Element>, _ count: Size)
+}
+
+extension CxxSpan {
+  /// Creates a C++ span from a Swift UnsafeBufferPointer
+  @inlinable
+  public init(_ unsafeBufferPointer: UnsafeBufferPointer<Element>) {
+    precondition(unsafeBufferPointer.baseAddress != nil, 
+                  "UnsafeBufferPointer should not point to nil")
+    self.init(unsafeBufferPointer.baseAddress!, Size(unsafeBufferPointer.count))
+  }
+}