[interop][SwiftToCxx] do not expose functions / properties that throw without the experimental feature

Author: hyp

include/swift/AST/DiagnosticsSema.def

@@ -1619,6 +1619,8 @@ ERROR(expose_generic_decl_to_cxx,none,
       "generic %0 %1 can not yet be exposed to C++", (DescriptiveDeclKind, ValueDecl *))
 ERROR(expose_generic_requirement_to_cxx,none,
       "generic requirements for %0 %1 can not yet be represented in C++", (DescriptiveDeclKind, ValueDecl *))
+ERROR(expose_throwing_to_cxx,none,
+      "%0 %1 can not yet be represented in C++ as it may throw an error", (DescriptiveDeclKind, ValueDecl *))
 
 ERROR(attr_methods_only,none,
       "only methods can be declared %0", (DeclAttribute))

include/swift/AST/SwiftNameTranslation.h

@@ -70,7 +70,8 @@ enum RepresentationError {
   UnrepresentableIsolatedInActor,
   UnrepresentableRequiresClientEmission,
   UnrepresentableGeneric,
-  UnrepresentableGenericRequirements
+  UnrepresentableGenericRequirements,
+  UnrepresentableThrows
 };
 
 struct DeclRepresentation {

include/swift/Basic/Features.def

@@ -174,6 +174,9 @@ EXPERIMENTAL_FEATURE(RuntimeDiscoverableAttrs, false)
 /// signatures.
 EXPERIMENTAL_FEATURE(ImportSymbolicCXXDecls, false)
 
+/// Generate bindings for functions that 'throw' in the C++ section of the generated Clang header.
+EXPERIMENTAL_FEATURE(GenerateBindingsForThrowingFunctionsInCXX, false)
+
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE
 #undef SUPPRESSIBLE_LANGUAGE_FEATURE

lib/AST/ASTPrinter.cpp

@@ -3170,6 +3170,10 @@ static bool usesFeatureBuiltinMacros(Decl *decl) {
 
 static bool usesFeatureImportSymbolicCXXDecls(Decl *decl) { return false; }
 
+static bool usesFeatureGenerateBindingsForThrowingFunctionsInCXX(Decl *decl) {
+  return false;
+}
+
 static bool usesFeatureFreestandingExpressionMacros(Decl *decl) {
   auto macro = dyn_cast<MacroDecl>(decl);
   if (!macro)

lib/AST/SwiftNameTranslation.cpp

@@ -179,6 +179,10 @@ swift::cxx_translation::getDeclRepresentation(const ValueDecl *VD) {
   if (auto *AFD = dyn_cast<AbstractFunctionDecl>(VD)) {
     if (AFD->hasAsync())
       return {Unsupported, UnrepresentableAsync};
+    if (AFD->hasThrows() &&
+        !AFD->getASTContext().LangOpts.hasFeature(
+            Feature::GenerateBindingsForThrowingFunctionsInCXX))
+      return {Unsupported, UnrepresentableThrows};
     // Don't expose @_alwaysEmitIntoClient functions as they require their
     // bodies to be emitted into client.
     if (AFD->getAttrs().hasAttribute<AlwaysEmitIntoClientAttr>())
@@ -194,6 +198,13 @@ swift::cxx_translation::getDeclRepresentation(const ValueDecl *VD) {
           typeDecl->getGenericSignature().getCanonicalSignature();
     }
   }
+  if (const auto *varDecl = dyn_cast<VarDecl>(VD)) {
+    // Check if any property accessor throws, do not expose it in that case.
+    for (const auto *accessor : varDecl->getAllAccessors()) {
+      if (accessor->hasThrows())
+        return {Unsupported, UnrepresentableThrows};
+    }
+  }
   // Generic requirements are not yet supported in C++.
   if (genericSignature && !genericSignature->getRequirements().empty())
     return {Unsupported, UnrepresentableGenericRequirements};

lib/Sema/TypeCheckAttr.cpp

@@ -2004,6 +2004,10 @@ void AttributeChecker::visitExposeAttr(ExposeAttr *attr) {
       diagnose(attr->getLocation(), diag::expose_generic_requirement_to_cxx,
                VD->getDescriptiveKind(), VD);
       break;
+    case UnrepresentableThrows:
+      diagnose(attr->getLocation(), diag::expose_throwing_to_cxx,
+               VD->getDescriptiveKind(), VD);
+      break;
     }
   }
 

test/Interop/SwiftToCxx/functions/swift-expected-execution.cpp

@@ -1,9 +1,9 @@
 // RUN: %empty-directory(%t)
 
-// RUN: %target-swift-frontend %S/swift-functions-errors.swift -typecheck -module-name Functions -Xcc -fno-exceptions -enable-experimental-cxx-interop -clang-header-expose-decls=has-expose-attr-or-stdlib -emit-clang-header-path %t/functions.h
+// RUN: %target-swift-frontend %S/swift-functions-errors.swift -typecheck -module-name Functions -Xcc -fno-exceptions -enable-experimental-cxx-interop -clang-header-expose-decls=has-expose-attr-or-stdlib -enable-experimental-feature GenerateBindingsForThrowingFunctionsInCXX -emit-clang-header-path %t/functions.h
 
 // RUN: %target-interop-build-clangxx -c %s -I %t -fno-exceptions -o %t/swift-expected-execution.o
-// RUN: %target-interop-build-swift %S/swift-functions-errors.swift -o %t/swift-expected-execution -Xlinker %t/swift-expected-execution.o -module-name Functions -Xfrontend -entry-point-function-name -Xfrontend swiftMain
+// RUN: %target-interop-build-swift %S/swift-functions-errors.swift -o %t/swift-expected-execution -Xlinker %t/swift-expected-execution.o -module-name Functions -Xfrontend -entry-point-function-name -Xfrontend swiftMain -enable-experimental-feature GenerateBindingsForThrowingFunctionsInCXX
 
 // RUN: %target-codesign %t/swift-expected-execution
 // RUN: %target-run %t/swift-expected-execution | %FileCheck %s
@@ -12,6 +12,9 @@
 // UNSUPPORTED: OS=windows-msvc
 // UNSUPPORTED: CPU=arm64e
 
+// for experimental feature GenerateBindingsForThrowingFunctionsInCXX:
+// REQUIRES: asserts
+
 #include <cassert>
 #include <cstdio>
 #include "functions.h"

test/Interop/SwiftToCxx/functions/swift-functions-errors-execution.cpp

@@ -1,9 +1,9 @@
 // RUN: %empty-directory(%t)
 
-// RUN: %target-swift-frontend %S/swift-functions-errors.swift -typecheck -module-name Functions -enable-experimental-cxx-interop -clang-header-expose-decls=has-expose-attr-or-stdlib  -emit-clang-header-path %t/functions.h
+// RUN: %target-swift-frontend %S/swift-functions-errors.swift -typecheck -module-name Functions -enable-experimental-cxx-interop -clang-header-expose-decls=has-expose-attr-or-stdlib -enable-experimental-feature GenerateBindingsForThrowingFunctionsInCXX -emit-clang-header-path %t/functions.h
 
 // RUN: %target-interop-build-clangxx -c %s -I %t -o %t/swift-functions-errors-execution.o
-// RUN: %target-interop-build-swift %S/swift-functions-errors.swift -o %t/swift-functions-errors-execution -Xlinker %t/swift-functions-errors-execution.o -module-name Functions -Xfrontend -entry-point-function-name -Xfrontend swiftMain
+// RUN: %target-interop-build-swift %S/swift-functions-errors.swift -o %t/swift-functions-errors-execution -Xlinker %t/swift-functions-errors-execution.o -module-name Functions -Xfrontend -entry-point-function-name -Xfrontend swiftMain -enable-experimental-feature GenerateBindingsForThrowingFunctionsInCXX
 
 // RUN: %target-codesign %t/swift-functions-errors-execution
 // RUN: %target-run %t/swift-functions-errors-execution | %FileCheck %s
@@ -14,6 +14,9 @@
 // rdar://102167469
 // UNSUPPORTED: CPU=arm64e
 
+// for experimental feature GenerateBindingsForThrowingFunctionsInCXX:
+// REQUIRES: asserts
+
 #include <cassert>
 #include <cstdio>
 #include "functions.h"

test/Interop/SwiftToCxx/functions/swift-functions-errors.swift

@@ -1,9 +1,12 @@
 // RUN: %empty-directory(%t)
-// RUN: %target-swift-frontend %s -typecheck -module-name Functions -enable-experimental-cxx-interop -clang-header-expose-decls=has-expose-attr-or-stdlib -emit-clang-header-path %t/functions.h
+// RUN: %target-swift-frontend %s -typecheck -module-name Functions -enable-experimental-cxx-interop -clang-header-expose-decls=has-expose-attr-or-stdlib -enable-experimental-feature GenerateBindingsForThrowingFunctionsInCXX -emit-clang-header-path %t/functions.h
 // RUN: %FileCheck %s < %t/functions.h
 
 // RUN: %check-interop-cxx-header-in-clang(%t/functions.h -DSWIFT_CXX_INTEROP_HIDE_STL_OVERLAY -Wno-unused-function)
 
+// for experimental feature GenerateBindingsForThrowingFunctionsInCXX:
+// REQUIRES: asserts
+
 // CHECK-LABEL: namespace Functions __attribute__((swift_private)) SWIFT_SYMBOL_MODULE("Functions") {
 
 // CHECK-LABEL: namespace _impl {

test/Interop/SwiftToCxx/unsupported/unsupported-funcs-in-cxx.swift

@@ -6,10 +6,34 @@
 // RUN: %FileCheck %s < %t/header.h
 
 // CHECK-NOT: unsupported
+// CHECK: HasMethods
 // CHECK: supported
 
 public func supported() {}
 
 @_expose(Cxx) // expected-error {{global function 'unsupportedAEIC()' can not be exposed to C++ as it requires code to be emitted into client}}
 @_alwaysEmitIntoClient
 public func unsupportedAEIC() {}
+
+@_expose(Cxx) // expected-error {{global function 'unsupportedThrows()' can not yet be represented in C++ as it may throw an error}}
+public func unsupportedThrows() throws {}
+
+@_expose(Cxx)
+public struct HasMethods {
+    let x: Int
+
+    @_expose(Cxx) // expected-error {{instance method 'unsupportedThrowsMethod()' can not yet be represented in C++ as it may throw an error}}
+    public func unsupportedThrowsMethod() throws {}
+
+    @_expose(Cxx) // expected-error {{initializer 'init()' can not yet be represented in C++ as it may throw an error}}
+    public init() throws {
+        self.x = 0
+    }
+
+    @_expose(Cxx) // expected-error {{property 'unsupportedProp' can not yet be represented in C++ as it may throw an error}}
+    public var unsupportedProp: Int {
+        get throws {
+            return 42
+        }
+    }
+}