[Frontend][Parse] Parse new named opaque return type syntax

include/swift/AST/GenericParamList.h

@@ -81,8 +81,6 @@ class RequirementRepr {
     : SeparatorLoc(SeparatorLoc), Kind(Kind), Invalid(false),
       FirstType(FirstType), SecondLayout(SecondLayout) { }
 
-  void printImpl(ASTPrinter &OS) const;
-
 public:
   /// Construct a new type-constraint requirement.
   ///
@@ -339,14 +337,15 @@ class GenericParamList final :
   /// to the given DeclContext.
   GenericParamList *clone(DeclContext *dc) const;
 
-  void print(raw_ostream &OS) const;
-  SWIFT_DEBUG_DUMP;
-
   bool walk(ASTWalker &walker);
 
   /// Finds a generic parameter declaration by name. This should only
   /// be used from the SIL parser.
   GenericTypeParamDecl *lookUpGenericParam(Identifier name) const;
+
+  SWIFT_DEBUG_DUMP;
+  void print(raw_ostream &OS, const PrintOptions &PO = PrintOptions()) const;
+  void print(ASTPrinter &Printer, const PrintOptions &PO) const;
 };
 
 /// A trailing where clause.

include/swift/AST/TypeRepr.h

@@ -1061,13 +1061,13 @@ class SILBoxTypeReprField {
   TypeRepr *getFieldType() const { return FieldTypeAndMutable.getPointer(); }
   bool isMutable() const { return FieldTypeAndMutable.getInt(); }
 };
-  
-/// TypeRepr for opaque return types.
+
+/// A TypeRepr for anonymous opaque return types.
 ///
-/// This can occur in the return position of a function declaration, or the
-/// top-level type of a property, to specify that the concrete return type
-/// should be abstracted from callers, given a set of generic constraints that
-/// the concrete return type satisfies:
+/// This can occur in the return type of a function declaration, or the type of
+/// a property, to specify that the concrete return type should be abstracted
+/// from callers, given a set of generic constraints that the concrete return
+/// type satisfies:
 ///
 /// func foo() -> some Collection { return [1,2,3] }
 /// var bar: some SignedInteger = 1
@@ -1101,6 +1101,41 @@ class OpaqueReturnTypeRepr : public TypeRepr {
   friend class TypeRepr;
 };
 
+/// A TypeRepr for a type with a generic parameter list of named opaque return
+/// types.
+///
+/// This can occur only as the return type of a function declaration, to specify
+/// subtypes which should be abstracted from callers, given a set of generic
+/// constraints that the concrete types satisfy:
+///
+/// func foo() -> <T: Collection> T { return [1] }
+class NamedOpaqueReturnTypeRepr : public TypeRepr {
+  TypeRepr *Base;
+  GenericParamList *GenericParams;
+
+public:
+  NamedOpaqueReturnTypeRepr(TypeRepr *Base, GenericParamList *GenericParams)
+      : TypeRepr(TypeReprKind::NamedOpaqueReturn), Base(Base),
+        GenericParams(GenericParams) {
+    assert(Base && GenericParams);
+  }
+
+  TypeRepr *getBase() const { return Base; }
+  GenericParamList *getGenericParams() const { return GenericParams; }
+
+  static bool classof(const TypeRepr *T) {
+    return T->getKind() == TypeReprKind::NamedOpaqueReturn;
+  }
+  static bool classof(const NamedOpaqueReturnTypeRepr *T) { return true; }
+
+private:
+  SourceLoc getStartLocImpl() const;
+  SourceLoc getEndLocImpl() const;
+  SourceLoc getLocImpl() const;
+  void printImpl(ASTPrinter &Printer, const PrintOptions &Opts) const;
+  friend class TypeRepr;
+};
+
 /// TypeRepr for a user-specified placeholder (essentially, a user-facing
 /// representation of an anonymous type variable.
 ///
@@ -1227,6 +1262,7 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::InOut:
   case TypeReprKind::Composition:
   case TypeReprKind::OpaqueReturn:
+  case TypeReprKind::NamedOpaqueReturn:
     return false;
   case TypeReprKind::SimpleIdent:
   case TypeReprKind::GenericIdent:

include/swift/AST/TypeReprNodes.def

@@ -54,6 +54,7 @@ TYPEREPR(Composition, TypeRepr)
 TYPEREPR(Metatype, TypeRepr)
 TYPEREPR(Protocol, TypeRepr)
 TYPEREPR(OpaqueReturn, TypeRepr)
+TYPEREPR(NamedOpaqueReturn, TypeRepr)
 TYPEREPR(Placeholder, TypeRepr)
 ABSTRACT_TYPEREPR(Specifier, TypeRepr)
   TYPEREPR(InOut, SpecifierTypeRepr)

include/swift/Basic/LangOptions.h

@@ -286,6 +286,11 @@ namespace swift {
     /// Enable experimental concurrency model.
     bool EnableExperimentalConcurrency = false;
 
+    /// Enable experimental support for additional opaque return type features,
+    /// i.e. named opaque return types (with 'where' clause support), and opaque
+    /// types in nested position within the function return type.
+    bool EnableExperimentalOpaqueReturnTypes = false;
+
     /// Enable experimental flow-sensitive concurrent captures.
     bool EnableExperimentalFlowSensitiveConcurrentCaptures = false;
 

include/swift/Option/FrontendOptions.td

@@ -437,6 +437,10 @@ def enable_experimental_static_assert :
   Flag<["-"], "enable-experimental-static-assert">,
   HelpText<"Enable experimental #assert">;
 
+def enable_experimental_opaque_return_types :
+  Flag<["-"], "enable-experimental-opaque-return-types">,
+  HelpText<"Enable experimental extensions to opaque return type support">;
+
 def enable_deserialization_recovery :
   Flag<["-"], "enable-deserialization-recovery">,
   HelpText<"Attempt to recover from missing xrefs (etc) in swiftmodules">;

include/swift/Parse/Parser.h

@@ -1223,6 +1223,13 @@ class Parser {
   ParserResult<TypeRepr> parseType(Diag<> MessageID,
                                    bool IsSILFuncDecl = false);
 
+  /// Parse a type optionally prefixed by a list of named opaque parameters. If
+  /// no params present, return 'type'. Otherwise, return 'type-named-opaque'.
+  ///
+  ///   type-named-opaque:
+  ///     generic-params type
+  ParserResult<TypeRepr> parseTypeWithOpaqueParams(Diag<> MessageID);
+
   ParserResult<TypeRepr>
     parseTypeSimpleOrComposition(Diag<> MessageID);
 

lib/AST/ASTDumper.cpp

@@ -21,7 +21,6 @@
 #include "swift/AST/ForeignAsyncConvention.h"
 #include "swift/AST/ForeignErrorConvention.h"
 #include "swift/AST/GenericEnvironment.h"
-#include "swift/AST/GenericParamList.h"
 #include "swift/AST/Initializer.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/ProtocolConformance.h"
@@ -114,107 +113,6 @@ namespace {
   };
 } // end anonymous namespace
 
-//===----------------------------------------------------------------------===//
-//  Generic param list printing.
-//===----------------------------------------------------------------------===//
-
-void RequirementRepr::dump() const {
-  print(llvm::errs());
-  llvm::errs() << "\n";
-}
-
-void RequirementRepr::printImpl(ASTPrinter &out) const {
-  auto printLayoutConstraint =
-      [&](const LayoutConstraintLoc &LayoutConstraintLoc) {
-        LayoutConstraintLoc.getLayoutConstraint()->print(out, PrintOptions());
-      };
-
-  switch (getKind()) {
-  case RequirementReprKind::LayoutConstraint:
-    if (auto *repr = getSubjectRepr()) {
-      repr->print(out, PrintOptions());
-    }
-    out << " : ";
-    printLayoutConstraint(getLayoutConstraintLoc());
-    break;
-
-  case RequirementReprKind::TypeConstraint:
-    if (auto *repr = getSubjectRepr()) {
-      repr->print(out, PrintOptions());
-    }
-    out << " : ";
-    if (auto *repr = getConstraintRepr()) {
-      repr->print(out, PrintOptions());
-    }
-    break;
-
-  case RequirementReprKind::SameType:
-    if (auto *repr = getFirstTypeRepr()) {
-      repr->print(out, PrintOptions());
-    }
-    out << " == ";
-    if (auto *repr = getSecondTypeRepr()) {
-      repr->print(out, PrintOptions());
-    }
-    break;
-  }
-}
-
-void RequirementRepr::print(raw_ostream &out) const {
-  StreamPrinter printer(out);
-  printImpl(printer);
-}
-void RequirementRepr::print(ASTPrinter &out) const {
-  printImpl(out);
-}
-
-static void printTrailingRequirements(ASTPrinter &Printer,
-                                      ArrayRef<RequirementRepr> Reqs,
-                                      bool printWhereKeyword) {
-  if (Reqs.empty()) return;
-
-  if (printWhereKeyword)
-    Printer << " where ";
-  interleave(
-      Reqs,
-      [&](const RequirementRepr &req) {
-        Printer.callPrintStructurePre(PrintStructureKind::GenericRequirement);
-        req.print(Printer);
-        Printer.printStructurePost(PrintStructureKind::GenericRequirement);
-      },
-      [&] { Printer << ", "; });
-}
-
-void GenericParamList::print(llvm::raw_ostream &OS) const {
-  OS << '<';
-  interleave(*this,
-             [&](const GenericTypeParamDecl *P) {
-               OS << P->getName();
-               if (!P->getInherited().empty()) {
-                 OS << " : ";
-                 P->getInherited()[0].getType().print(OS);
-               }
-             },
-             [&] { OS << ", "; });
-
-  StreamPrinter Printer(OS);
-  printTrailingRequirements(Printer, getRequirements(),
-                            /*printWhereKeyword*/true);
-  OS << '>';
-}
-
-void GenericParamList::dump() const {
-  print(llvm::errs());
-  llvm::errs() << '\n';
-}
-
-void TrailingWhereClause::print(llvm::raw_ostream &OS,
-                                bool printWhereKeyword) const {
-  StreamPrinter Printer(OS);
-  printTrailingRequirements(Printer, getRequirements(),
-                            printWhereKeyword);
-}
-
 static void printGenericParameters(raw_ostream &OS, GenericParamList *Params) {
   if (!Params)
     return;
@@ -3139,6 +3037,12 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr> {
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
 
+  void visitNamedOpaqueReturnTypeRepr(NamedOpaqueReturnTypeRepr *T) {
+    printCommon("type_named_opaque_return") << '\n';
+    printRec(T->getBase());
+    PrintWithColorRAII(OS, ParenthesisColor) << ')';
+  }
+
   void visitPlaceholderTypeRepr(PlaceholderTypeRepr *T) {
     printCommon("type_placeholder");
     PrintWithColorRAII(OS, ParenthesisColor) << ')';

lib/AST/ASTPrinter.cpp

@@ -26,6 +26,7 @@
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/FileUnit.h"
+#include "swift/AST/GenericParamList.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/NameLookup.h"
@@ -5851,3 +5852,113 @@ swift::getInheritedForPrinting(const Decl *decl, const PrintOptions &options,
     }
   }
 }
+
+//===----------------------------------------------------------------------===//
+//  Generic param list printing.
+//===----------------------------------------------------------------------===//
+
+void RequirementRepr::dump() const {
+  print(llvm::errs());
+  llvm::errs() << "\n";
+}
+
+void RequirementRepr::print(raw_ostream &out) const {
+  StreamPrinter printer(out);
+  print(printer);
+}
+
+void RequirementRepr::print(ASTPrinter &out) const {
+  auto printLayoutConstraint =
+      [&](const LayoutConstraintLoc &LayoutConstraintLoc) {
+        LayoutConstraintLoc.getLayoutConstraint()->print(out, PrintOptions());
+      };
+
+  switch (getKind()) {
+  case RequirementReprKind::LayoutConstraint:
+    if (auto *repr = getSubjectRepr()) {
+      repr->print(out, PrintOptions());
+    }
+    out << " : ";
+    printLayoutConstraint(getLayoutConstraintLoc());
+    break;
+
+  case RequirementReprKind::TypeConstraint:
+    if (auto *repr = getSubjectRepr()) {
+      repr->print(out, PrintOptions());
+    }
+    out << " : ";
+    if (auto *repr = getConstraintRepr()) {
+      repr->print(out, PrintOptions());
+    }
+    break;
+
+  case RequirementReprKind::SameType:
+    if (auto *repr = getFirstTypeRepr()) {
+      repr->print(out, PrintOptions());
+    }
+    out << " == ";
+    if (auto *repr = getSecondTypeRepr()) {
+      repr->print(out, PrintOptions());
+    }
+    break;
+  }
+}
+
+void GenericParamList::dump() const {
+  print(llvm::errs());
+  llvm::errs() << '\n';
+}
+
+void GenericParamList::print(raw_ostream &out, const PrintOptions &PO) const {
+  StreamPrinter printer(out);
+  print(printer, PO);
+}
+
+static void printTrailingRequirements(ASTPrinter &Printer,
+                                      ArrayRef<RequirementRepr> Reqs,
+                                      bool printWhereKeyword) {
+  if (Reqs.empty())
+    return;
+
+  if (printWhereKeyword)
+    Printer << " where ";
+  interleave(
+      Reqs,
+      [&](const RequirementRepr &req) {
+        Printer.callPrintStructurePre(PrintStructureKind::GenericRequirement);
+        req.print(Printer);
+        Printer.printStructurePost(PrintStructureKind::GenericRequirement);
+      },
+      [&] { Printer << ", "; });
+}
+
+void GenericParamList::print(ASTPrinter &Printer,
+                             const PrintOptions &PO) const {
+  Printer << '<';
+  interleave(
+      *this,
+      [&](const GenericTypeParamDecl *P) {
+        Printer << P->getName();
+        if (!P->getInherited().empty()) {
+          Printer << " : ";
+
+          auto loc = P->getInherited()[0];
+          if (willUseTypeReprPrinting(loc, nullptr, PO)) {
+            loc.getTypeRepr()->print(Printer, PO);
+          } else {
+            loc.getType()->print(Printer, PO);
+          }
+        }
+      },
+      [&] { Printer << ", "; });
+
+  printTrailingRequirements(Printer, getRequirements(),
+                            /*printWhereKeyword*/ true);
+  Printer << '>';
+}
+
+void TrailingWhereClause::print(llvm::raw_ostream &OS,
+                                bool printWhereKeyword) const {
+  StreamPrinter Printer(OS);
+  printTrailingRequirements(Printer, getRequirements(), printWhereKeyword);
+}