Merge pull request #76491 from gottesmm/rdar135594964

[sending] Look through the sending type repr when printing the type of a function result using the type repr fallback path.

Author: gottesmm

lib/AST/ASTPrinter.cpp

@@ -4144,8 +4144,35 @@ void PrintAST::visitFuncDecl(FuncDecl *decl) {
       }
 
       PrintWithOpaqueResultTypeKeywordRAII x(Options);
-      printTypeLocForImplicitlyUnwrappedOptional(
-          ResultTyLoc, decl->isImplicitlyUnwrappedOptional());
+
+      // Check if we would go down the type repr path... in such a case, see if
+      // we can find a type repr and if that type has a sending type repr. In
+      // such a case, look through the sending type repr since we handle it here
+      // ourselves.
+      bool usedTypeReprPrinting = false;
+      {
+        llvm::SaveAndRestore<PrintOptions> printOptions(Options);
+        Options.PrintOptionalAsImplicitlyUnwrapped =
+            decl->isImplicitlyUnwrappedOptional();
+        if (willUseTypeReprPrinting(ResultTyLoc, CurrentType, Options)) {
+          if (auto repr = ResultTyLoc.getTypeRepr()) {
+            // If we are printing a sending result... and we found that we have
+            // to use type repr printing, look through sending type repr.
+            // Sending was already applied in our caller.
+            if (auto *sendingRepr = dyn_cast<SendingTypeRepr>(repr)) {
+              repr = sendingRepr->getBase();
+            }
+            repr->print(Printer, Options);
+            usedTypeReprPrinting = true;
+          }
+        }
+      }
+
+      // If we printed using type repr printing, do not print again.
+      if (!usedTypeReprPrinting) {
+        printTypeLocForImplicitlyUnwrappedOptional(
+            ResultTyLoc, decl->isImplicitlyUnwrappedOptional());
+      }
       Printer.printStructurePost(PrintStructureKind::FunctionReturnType);
     }
     printDeclGenericRequirements(decl);

lib/AST/TypeRepr.cpp

@@ -435,7 +435,21 @@ void FunctionTypeRepr::printImpl(ASTPrinter &Printer,
   }
   Printer << " -> ";
   Printer.callPrintStructurePre(PrintStructureKind::FunctionReturnType);
-  printTypeRepr(RetTy, Printer, Opts);
+
+  // Check if we are supposed to suppress sending results. If so, look through
+  // the ret ty if it is a Sending TypeRepr.
+  //
+  // DISCUSSION: The reason why we do this is that Sending TypeRepr is used for
+  // arguments and results... and we need the arguments case when we suppress to
+  // print __owned. So this lets us handle both cases.
+  auto ActualRetTy = RetTy;
+  if (Opts.SuppressSendingArgsAndResults) {
+    if (auto *x = dyn_cast<SendingTypeRepr>(RetTy)) {
+      ActualRetTy = x->getBase();
+    }
+  }
+  printTypeRepr(ActualRetTy, Printer, Opts);
+
   Printer.printStructurePost(PrintStructureKind::FunctionReturnType);
   Printer.printStructurePost(PrintStructureKind::FunctionType);
 }
@@ -853,7 +867,13 @@ void SpecifierTypeRepr::printImpl(ASTPrinter &Printer,
     Printer.printKeyword("isolated", Opts, " ");
     break;
   case TypeReprKind::Sending:
-    Printer.printKeyword("sending", Opts, " ");
+    // This handles the argument case. The result case is handled in
+    // FunctionTypeRepr.
+    if (!Opts.SuppressSendingArgsAndResults) {
+      Printer.printKeyword("sending", Opts, " ");
+    } else {
+      Printer.printKeyword("__owned", Opts, " ");
+    }
     break;
   case TypeReprKind::CompileTimeConst:
     Printer.printKeyword("_const", Opts, " ");

test/Concurrency/Inputs/sending_interfacefile_printing_repr_filecheck

@@ -0,0 +1,18 @@
+
+// CHECK: #if compiler(>=5.3) && $SendingArgsAndResults
+// CHECK-NEXT: public func test() -> sending NonSendableKlass
+// CHECK-NEXT: #else
+// CHECK-NEXT: public func test() -> NonSendableKlass
+// CHECK-NEXT: #endif
+
+// CHECK: #if compiler(>=5.3) && $SendingArgsAndResults
+// CHECK-NEXT: public func test2(_ x: sending NonSendableKlass)
+// CHECK-NEXT: #else
+// CHECK-NEXT: public func test2(_ x: __owned NonSendableKlass)
+// CHECK-NEXT: #endif
+
+// CHECK: #if compiler(>=5.3) && $SendingArgsAndResults
+// CHECK-NEXT: @_Concurrency.MainActor public var closure: () -> sending NonSendableKlass
+// CHECK-NEXT: #else
+// CHECK-NEXT: @_Concurrency.MainActor public var closure: () -> NonSendableKlass
+// CHECK-NEXT: #endif

test/Concurrency/sending_interfacefile_printing.swift

@@ -0,0 +1,36 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend %s -typecheck -enable-library-evolution -parse-as-library -emit-module-interface-path - -module-name MyFile -swift-version 6 | %FileCheck %s
+// RUN: %target-swift-frontend %s -typecheck -enable-library-evolution -parse-as-library -emit-module-interface-path - -module-name MyFile -swift-version 6 -module-interface-preserve-types-as-written | %FileCheck %S/Inputs/sending_interfacefile_printing_repr_filecheck
+
+// The force printing type reprs option is only available in asserts builds.
+// REQUIRES: asserts
+
+// This test validates that when we produce interface files we produce the
+// correct interface file for sending when printing normally or with type reprs
+// enabled.
+
+public class NonSendableKlass {}
+
+// The two possible outputs are MyFile.NonSendableKlass and NonSendableKlass.
+//
+// So we just check for an optional M
+// CHECK: #if compiler(>=5.3) && $SendingArgsAndResults
+// CHECK-NEXT: public func test() -> sending MyFile.NonSendableKlass
+// CHECK-NEXT: #else
+// CHECK-NEXT: public func test() -> MyFile.NonSendableKlass
+// CHECK-NEXT: #endif
+public func test() -> sending NonSendableKlass { NonSendableKlass() }
+
+// CHECK: #if compiler(>=5.3) && $SendingArgsAndResults
+// CHECK-NEXT: public func test2(_ x: sending MyFile.NonSendableKlass)
+// CHECK-NEXT: #else
+// CHECK-NEXT: public func test2(_ x: __owned MyFile.NonSendableKlass)
+// CHECK-NEXT: #endif
+public func test2(_ x: sending NonSendableKlass) {}
+
+// CHECK: #if compiler(>=5.3) && $SendingArgsAndResults
+// CHECK-NEXT: @_Concurrency.MainActor public var closure: () -> sending MyFile.NonSendableKlass
+// CHECK-NEXT: #else
+// CHECK-NEXT: @_Concurrency.MainActor public var closure: () -> MyFile.NonSendableKlass
+// CHECK-NEXT: #endif
+@MainActor public var closure: () -> sending NonSendableKlass = { NonSendableKlass() }