[interop][SwiftToCxx] experimentally expose exposable Swift's Array members to C++

Author: hyp

lib/PrintAsClang/DeclAndTypePrinter.cpp

@@ -1818,6 +1818,8 @@ class DeclAndTypePrinter::Implementation
   }
 
   void visitSubscriptDecl(SubscriptDecl *SD) {
+    if (outputLang == OutputLanguageMode::Cxx)
+      return;
     assert(SD->isInstanceMember() && "static subscripts not supported");
 
     bool isNSUIntegerSubscript = false;
@@ -2522,9 +2524,9 @@ static bool isAsyncAlternativeOfOtherDecl(const ValueDecl *VD) {
   return false;
 }
 
-static bool hasExposeAttr(const ValueDecl *VD) {
+static bool hasExposeAttr(const ValueDecl *VD, bool isExtension = false) {
   if (isa<NominalTypeDecl>(VD) && VD->getModuleContext()->isStdlibModule()) {
-    if (VD == VD->getASTContext().getStringDecl())
+    if (VD == VD->getASTContext().getStringDecl() && !isExtension)
       return true;
     if (VD == VD->getASTContext().getArrayDecl())
       return true;
@@ -2534,6 +2536,26 @@ static bool hasExposeAttr(const ValueDecl *VD) {
     return true;
   if (const auto *NMT = dyn_cast<NominalTypeDecl>(VD->getDeclContext()))
     return hasExposeAttr(NMT);
+  if (const auto *ED = dyn_cast<ExtensionDecl>(VD->getDeclContext())) {
+    // FIXME: Do not expose 'index' methods as the overloads are conflicting.
+    // this should either be prohibited in the stdlib module, or the overloads
+    // should be renamed automatically or using the expose attribute.
+    if (ED->getExtendedNominal() == VD->getASTContext().getArrayDecl()) {
+      if (isa<AbstractFunctionDecl>(VD) &&
+          !cast<AbstractFunctionDecl>(VD)
+               ->getName()
+               .getBaseName()
+               .isSpecial() &&
+          cast<AbstractFunctionDecl>(VD)
+              ->getName()
+              .getBaseName()
+              .getIdentifier()
+              .str()
+              .contains_insensitive("index"))
+        return false;
+    }
+    return hasExposeAttr(ED->getExtendedNominal(), /*isExtension=*/true);
+  }
   return false;
 }
 

lib/PrintAsClang/ModuleContentsWriter.cpp

@@ -227,8 +227,11 @@ class ModuleWriter {
 
   void forwardDeclare(const NominalTypeDecl *NTD,
                       llvm::function_ref<void(void)> Printer) {
-    if (NTD->getModuleContext()->isStdlibModule())
-      return;
+    if (NTD->getModuleContext()->isStdlibModule()) {
+      if (outputLangMode != OutputLanguageMode::Cxx ||
+          !printer.shouldInclude(NTD))
+        return;
+    }
     auto &state = seenTypes[NTD];
     if (state.second)
       return;

lib/PrintAsClang/PrintClangFunction.cpp

@@ -295,7 +295,9 @@ class CFunctionSignatureTypePrinter
     if (!declPrinter.shouldInclude(decl))
       return ClangRepresentation::unsupported; // FIXME: propagate why it's not
                                                // exposed.
-
+    // FIXME: Support Optional<T>.
+    if (optionalKind && *optionalKind != OTK_None)
+      return ClangRepresentation::unsupported;
     // Only C++ mode supports struct types.
     if (languageMode != OutputLanguageMode::Cxx)
       return ClangRepresentation::unsupported;
@@ -337,36 +339,45 @@ class CFunctionSignatureTypePrinter
     return ClangRepresentation::representable;
   }
 
-  bool printIfKnownGenericStruct(const BoundGenericStructType *BGT,
-                                 Optional<OptionalTypeKind> optionalKind,
-                                 bool isInOutParam) {
+  Optional<ClangRepresentation>
+  printIfKnownGenericStruct(const BoundGenericStructType *BGT,
+                            Optional<OptionalTypeKind> optionalKind,
+                            bool isInOutParam) {
     auto bgsTy = Type(const_cast<BoundGenericStructType *>(BGT));
     bool isConst;
     if (bgsTy->isUnsafePointer())
       isConst = true;
     else if (bgsTy->isUnsafeMutablePointer())
       isConst = false;
     else
-      return false;
+      return None;
 
     auto args = BGT->getGenericArgs();
     assert(args.size() == 1);
-    visitPart(args.front(), OTK_None, /*isInOutParam=*/false);
+    llvm::SaveAndRestore<FunctionSignatureTypeUse> typeUseNormal(
+        typeUseKind, FunctionSignatureTypeUse::TypeReference);
+    // FIXME: We can definitely support pointers to known Clang types.
+    if (!isKnownCType(args.front(), typeMapping))
+      return ClangRepresentation(ClangRepresentation::unsupported);
+    auto partRepr = visitPart(args.front(), OTK_None, /*isInOutParam=*/false);
+    if (partRepr.isUnsupported())
+      return partRepr;
     if (isConst)
       os << " const";
     os << " *";
     printNullability(optionalKind);
     if (isInOutParam)
       printInoutTypeModifier();
-    return true;
+    return ClangRepresentation(ClangRepresentation::representable);
   }
 
   ClangRepresentation
   visitBoundGenericStructType(BoundGenericStructType *BGT,
                               Optional<OptionalTypeKind> optionalKind,
                               bool isInOutParam) {
-    if (printIfKnownGenericStruct(BGT, optionalKind, isInOutParam))
-      return ClangRepresentation::representable;
+    if (auto result =
+            printIfKnownGenericStruct(BGT, optionalKind, isInOutParam))
+      return *result;
     return visitValueType(BGT, BGT->getDecl(), optionalKind, isInOutParam,
                           BGT->getGenericArgs());
   }
@@ -375,11 +386,17 @@ class CFunctionSignatureTypePrinter
   visitGenericTypeParamType(GenericTypeParamType *genericTpt,
                             Optional<OptionalTypeKind> optionalKind,
                             bool isInOutParam) {
+    // FIXME: Support Optional<T>.
+    if (optionalKind && *optionalKind != OTK_None)
+      return ClangRepresentation::unsupported;
     bool isParam = typeUseKind == FunctionSignatureTypeUse::ParamType;
     if (isParam && !isInOutParam)
       os << "const ";
     // FIXME: handle optionalKind.
     if (languageMode != OutputLanguageMode::Cxx) {
+      // Note: This can happen for UnsafeMutablePointer<T>.
+      if (typeUseKind != FunctionSignatureTypeUse::ParamType)
+        return ClangRepresentation::unsupported;
       assert(typeUseKind == FunctionSignatureTypeUse::ParamType);
       // Pass an opaque param in C mode.
       os << "void * _Nonnull";
@@ -1194,9 +1211,11 @@ void DeclAndTypeClangFunctionPrinter::printCxxPropertyAccessorMethod(
 bool DeclAndTypeClangFunctionPrinter::hasKnownOptionalNullableCxxMapping(
     Type type) {
   if (auto optionalObjectType = type->getOptionalObjectType()) {
-    if (auto typeInfo = typeMapping.getKnownCxxTypeInfo(
-            optionalObjectType->getNominalOrBoundGenericNominal())) {
-      return typeInfo->canBeNullable;
+    if (optionalObjectType->getNominalOrBoundGenericNominal()) {
+      if (auto typeInfo = typeMapping.getKnownCxxTypeInfo(
+              optionalObjectType->getNominalOrBoundGenericNominal())) {
+        return typeInfo->canBeNullable;
+      }
     }
   }
   return false;

test/Interop/SwiftToCxx/stdlib/array/array-execution.cpp

@@ -42,5 +42,18 @@ int main() {
     UseArray::printArray(UseArray::passthroughArray(val));
   }
 // CHECK: [2, 2]
+  {
+    auto val = Array<int>::init();
+    val.append(-11);
+    UseArray::printArray(val);
+    assert(val.getCount() == 1);
+    assert(val.getCapacity() >= 1);
+    auto firstInt = val.remove(0);
+    assert(firstInt == -11);
+    assert(val.getCount() == 0);
+    UseArray::printArray(val);
+  }
+// CHECK-NEXT: [-11]
+// CHECK-NEXT: []
   return 0;
 }

test/Interop/SwiftToCxx/stdlib/swift-stdlib-in-cxx.swift

@@ -6,6 +6,8 @@
 
 // CHECK: namespace Swift {
 
+// CHECK: class String;
+
 // CHECK: template<class T_0_0>
 // CHECK: template<class T_0_0>
 // CHECK-NEXT: requires swift::isUsableInGenericContext<T_0_0>
@@ -15,6 +17,11 @@
 // CHECK: }
 // CHECK-NEXT: inline Array(const Array &other) {
 // CHECK: }
+// CHECK: static inline Array<T_0_0> init();
+// CHECK: inline void append(const T_0_0& newElement);
+// CHECK: inline T_0_0 remove(swift::Int index);
+// CHECK: inline swift::Int getCount() const;
+// CHECK: inline swift::Int getCapacity() const;
 
 // CHECK: class String final {
 // CHECK-NEXT: public: