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

When we print types in the AST printer if for some reason we cannot find the
appropriate type to print, we fall back and use a type repr instead. This
behavior is a fallback case that is hit rarely (or we would have seen this
behavior earlier).

This behavior causes a problem due to the implementation of sending results
using a sending type repr to communicate that the relevant Function has a
sending result, but we actually do not use the sending type repr from that point
on. So as a result, in this fallback case, we put in one too many sending on the
result.

Previously, it was pretty hard to test this codepath, so I added a small option
that is available only in asserts builds that turns on the type repr behavior
all the time.

rdar://135594964

Author: gottesmm

include/swift/AST/PrintOptions.h

@@ -345,6 +345,13 @@ struct PrintOptions {
   /// Whether to print the \c{/*not inherited*/} comment on factory initializers.
   bool PrintFactoryInitializerComment = true;
 
+  /// If set to true this is for a function result.
+  ///
+  /// In practice, this causes us to look through "sending type reprs" when
+  /// printing functions along the type repr backup path that is used if we are
+  /// printing a function result type that is null.
+  bool IsForFunctionResult = false;
+
   /// How to print opaque return types.
   enum class OpaqueReturnTypePrintingMode {
     /// 'some P1 & P2'.

lib/AST/ASTPrinter.cpp

@@ -933,8 +933,17 @@ class PrintAST : public ASTVisitor<PrintAST> {
     // Print a TypeRepr if instructed to do so by options, or if the type
     // is null.
     if (willUseTypeReprPrinting(TL, CurrentType, options)) {
-      if (auto repr = TL.getTypeRepr())
+      if (auto repr = TL.getTypeRepr()) {
+        if (Options.IsForFunctionResult) {
+          // 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);
+      }
       return;
     }
 
@@ -4037,6 +4046,23 @@ void PrintAST::visitAccessorDecl(AccessorDecl *decl) {
   printBodyIfNecessary(decl);
 }
 
+/// Forces printing types with the `some` keyword, instead of the full stable
+/// reference.
+struct PrintForFunctionResultRAII {
+  PrintForFunctionResultRAII(PrintOptions &Options)
+      : Options(Options) {
+    SavedMode = Options.IsForFunctionResult;
+    Options.IsForFunctionResult = true;
+  }
+  ~PrintForFunctionResultRAII() {
+    Options.IsForFunctionResult = SavedMode;
+  }
+
+private:
+  PrintOptions &Options;
+  bool SavedMode;
+};
+
 void PrintAST::visitFuncDecl(FuncDecl *decl) {
   ASTContext &Ctx = decl->getASTContext();
 
@@ -4139,6 +4165,8 @@ void PrintAST::visitFuncDecl(FuncDecl *decl) {
       }
 
       PrintWithOpaqueResultTypeKeywordRAII x(Options);
+      PrintForFunctionResultRAII assumingFunctionResult(Options);
+
       printTypeLocForImplicitlyUnwrappedOptional(
           ResultTyLoc, decl->isImplicitlyUnwrappedOptional());
       Printer.printStructurePost(PrintStructureKind::FunctionReturnType);

test/Concurrency/Inputs/sending_interfacefile_printing_repr_filecheck

@@ -0,0 +1,6 @@
+
+// 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

test/Concurrency/sending_interfacefile_printing.swift

@@ -0,0 +1,23 @@
+// 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 -DFILE_PREFIX=MyFile %s
+// RUN: %target-swift-frontend %s -typecheck -enable-library-evolution -parse-as-library -emit-module-interface-path - -module-name MyFile -swift-version 6 -Xllvm --swift-ast-printer-force-printing-types-as-type-reprs | %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() }