Merge pull request #76300 from tshortli/module-interface-patterns-with-opaque-results

ModuleInterface: Print patterns with opaque result types using `some` keyword

Author: tshortli

lib/AST/ASTPrinter.cpp

@@ -182,6 +182,24 @@ static bool shouldPrintAllSemanticDetails(const PrintOptions &options) {
   return false;
 }
 
+/// Forces printing types with the `some` keyword, instead of the full stable
+/// reference.
+struct PrintWithOpaqueResultTypeKeywordRAII {
+  PrintWithOpaqueResultTypeKeywordRAII(PrintOptions &Options)
+      : Options(Options) {
+    SavedMode = Options.OpaqueReturnTypePrinting;
+    Options.OpaqueReturnTypePrinting =
+        PrintOptions::OpaqueReturnTypePrintingMode::WithOpaqueKeyword;
+  }
+  ~PrintWithOpaqueResultTypeKeywordRAII() {
+    Options.OpaqueReturnTypePrinting = SavedMode;
+  }
+
+private:
+  PrintOptions &Options;
+  PrintOptions::OpaqueReturnTypePrintingMode SavedMode;
+};
+
 PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
                                                    bool preferTypeRepr,
                                                    bool printFullConvention,
@@ -1317,6 +1335,8 @@ void PrintAST::printTypedPattern(const TypedPattern *TP) {
   printPattern(TP->getSubPattern());
   Printer << ": ";
 
+  PrintWithOpaqueResultTypeKeywordRAII x(Options);
+
   // Make sure to check if the underlying var decl is an implicitly unwrapped
   // optional.
   bool isIUO = false;
@@ -3745,13 +3765,7 @@ void PrintAST::visitVarDecl(VarDecl *decl) {
     }
     Printer.printDeclResultTypePre(decl, tyLoc);
 
-    // HACK: When printing result types for vars with opaque result types,
-    //       always print them using the `some` keyword instead of printing
-    //       the full stable reference.
-    llvm::SaveAndRestore<PrintOptions::OpaqueReturnTypePrintingMode>
-    x(Options.OpaqueReturnTypePrinting,
-      PrintOptions::OpaqueReturnTypePrintingMode::WithOpaqueKeyword);
-
+    PrintWithOpaqueResultTypeKeywordRAII x(Options);
     printTypeLocForImplicitlyUnwrappedOptional(
       tyLoc, decl->isImplicitlyUnwrappedOptional());
   }
@@ -4127,13 +4141,7 @@ void PrintAST::visitFuncDecl(FuncDecl *decl) {
         }
       }
 
-      // HACK: When printing result types for funcs with opaque result types,
-      //       always print them using the `some` keyword instead of printing
-      //       the full stable reference.
-      llvm::SaveAndRestore<PrintOptions::OpaqueReturnTypePrintingMode>
-      x(Options.OpaqueReturnTypePrinting,
-        PrintOptions::OpaqueReturnTypePrintingMode::WithOpaqueKeyword);
-
+      PrintWithOpaqueResultTypeKeywordRAII x(Options);
       printTypeLocForImplicitlyUnwrappedOptional(
           ResultTyLoc, decl->isImplicitlyUnwrappedOptional());
       Printer.printStructurePost(PrintStructureKind::FunctionReturnType);
@@ -4283,13 +4291,7 @@ void PrintAST::visitSubscriptDecl(SubscriptDecl *decl) {
     Printer.printDeclResultTypePre(decl, elementTy);
     Printer.callPrintStructurePre(PrintStructureKind::FunctionReturnType);
 
-    // HACK: When printing result types for subscripts with opaque result types,
-    //       always print them using the `some` keyword instead of printing
-    //       the full stable reference.
-    llvm::SaveAndRestore<PrintOptions::OpaqueReturnTypePrintingMode>
-    x(Options.OpaqueReturnTypePrinting,
-      PrintOptions::OpaqueReturnTypePrintingMode::WithOpaqueKeyword);
-
+    PrintWithOpaqueResultTypeKeywordRAII x(Options);
     printTypeLocForImplicitlyUnwrappedOptional(
       elementTy, decl->isImplicitlyUnwrappedOptional());
     Printer.printStructurePost(PrintStructureKind::FunctionReturnType);

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2771,7 +2771,18 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         // Properties with an opaque return type need an initializer to
         // determine their underlying type.
         if (var->getOpaqueResultTypeDecl()) {
-          var->diagnose(diag::opaque_type_var_no_init);
+          // ...but don't enforce this for SIL or module interface files.
+          switch (SF->Kind) {
+          case SourceFileKind::Interface:
+          case SourceFileKind::SIL:
+            break;
+          case SourceFileKind::DefaultArgument:
+          case SourceFileKind::Main:
+          case SourceFileKind::Library:
+          case SourceFileKind::MacroExpansion:
+            var->diagnose(diag::opaque_type_var_no_init);
+            break;
+          }
         }
 
         // Non-member observing properties need an initializer.

test/ModuleInterface/Inputs/opaque-result-types-client.swift

@@ -60,4 +60,19 @@ func someTypeIsTheSame() {
   f = barString.foo(MyFoo()) // expected-error{{cannot assign}}
   f = barInt.foo(YourFoo()) // expected-error{{cannot convert value of type 'YourFoo' to expected argument type 'MyFoo'}}
   f = barString.foo(MyFoo()) // expected-error{{cannot assign}}
+
+  var g = globalComputedVar
+  g = globalVar // expected-error{{cannot assign}}
+  g = globalComputedVar
+  g = 123 // expected-error{{cannot assign}}
+
+  var h = globalVar
+  h = globalComputedVar // expected-error{{cannot assign}}
+  h = globalVar
+  h = 123 // expected-error{{cannot assign}}
+
+  var i = globalVarTuple
+  i = (123, foo(123)) // expected-error{{cannot assign}}
+  i = globalVarTuple
+  i = (globalVarTuple.0, globalVarTuple.1)
 }

test/ModuleInterface/opaque-result-types.swift

@@ -25,6 +25,20 @@ public func foo<T: Foo>(_ x: T) -> some Foo {
   return x
 }
 
+// CHECK-LABEL: public var globalComputedVar: some OpaqueResultTypes.Foo {
+// CHECK-NEXT:    get
+// CHECK-NEXT:  }
+@available(SwiftStdlib 5.1, *)
+public var globalComputedVar: some Foo { 123 }
+
+// CHECK-LABEL: public var globalVar: some OpaqueResultTypes.Foo{{$}}
+@available(SwiftStdlib 5.1, *)
+public var globalVar: some Foo = 123
+
+// CHECK-LABEL: public var globalVarTuple: (some OpaqueResultTypes.Foo, some OpaqueResultTypes.Foo){{$}}
+@available(SwiftStdlib 5.1, *)
+public var globalVarTuple: (some Foo, some Foo) = (123, foo(123))
+
 public protocol AssocTypeInference {
   associatedtype Assoc: Foo
   associatedtype AssocProperty: Foo