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

In order to put constraints on opaque types in function returns, we want to
support naming them like 'func f() -> <T> T { }'. This commit parses that
syntax into the new `OpaqueReturnParameteriedTypeRepr`. This is hidden behind
the new flag --enable-experimental-opaque-return-types.

Author: Benjamin Driscoll

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,42 @@ 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 OpaqueReturnParameterizedTypeRepr : public TypeRepr {
+  TypeRepr *Base;
+  GenericParamList *GenericParams;
+
+public:
+  OpaqueReturnParameterizedTypeRepr(TypeRepr *Base,
+                                    GenericParamList *GenericParams)
+      : TypeRepr(TypeReprKind::OpaqueReturnParameterized), Base(Base),
+        GenericParams(GenericParams) {}
+
+  TypeRepr *getBase() const { return Base; }
+  GenericParamList *getGenericParams() const { return GenericParams; }
+
+  static bool classof(const TypeRepr *T) {
+    return T->getKind() == TypeReprKind::OpaqueReturnParameterized;
+  }
+  static bool classof(const OpaqueReturnParameterizedTypeRepr *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.
 ///
@@ -1245,6 +1281,8 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::Isolated:
   case TypeReprKind::Placeholder:
     return true;
+  case TypeReprKind::OpaqueReturnParameterized:
+    return cast<OpaqueReturnParameterizedTypeRepr>(this)->getBase()->isSimple();
   }
   llvm_unreachable("bad TypeRepr kind");
 }

include/swift/AST/TypeReprNodes.def

@@ -54,6 +54,7 @@ TYPEREPR(Composition, TypeRepr)
 TYPEREPR(Metatype, TypeRepr)
 TYPEREPR(Protocol, TypeRepr)
 TYPEREPR(OpaqueReturn, TypeRepr)
+TYPEREPR(OpaqueReturnParameterized, 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">;

lib/AST/ASTDumper.cpp

@@ -3139,6 +3139,13 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr> {
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
 
+  void
+  visitOpaqueReturnParameterizedTypeRepr(OpaqueReturnParameterizedTypeRepr *T) {
+    printCommon("type_opaque_return_parameterized") << '\n';
+    printRec(T->getBase());
+    PrintWithColorRAII(OS, ParenthesisColor) << ')';
+  }
+
   void visitPlaceholderTypeRepr(PlaceholderTypeRepr *T) {
     printCommon("type_placeholder");
     PrintWithColorRAII(OS, ParenthesisColor) << ')';

lib/AST/ASTWalker.cpp

@@ -1858,6 +1858,11 @@ bool Traversal::visitOpaqueReturnTypeRepr(OpaqueReturnTypeRepr *T) {
   return doIt(T->getConstraint());
 }
 
+bool Traversal::visitOpaqueReturnParameterizedTypeRepr(
+    OpaqueReturnParameterizedTypeRepr *T) {
+  return doIt(T->getBase());
+}
+
 bool Traversal::visitPlaceholderTypeRepr(PlaceholderTypeRepr *T) {
   return false;
 }

lib/AST/NameLookup.cpp

@@ -2261,8 +2261,9 @@ directReferencesForTypeRepr(Evaluator &evaluator,
   case TypeReprKind::SILBox:
   case TypeReprKind::Placeholder:
     return { };
-      
+
   case TypeReprKind::OpaqueReturn:
+  case TypeReprKind::OpaqueReturnParameterized:
     return { };
 
   case TypeReprKind::Fixed:

lib/AST/TypeRepr.cpp

@@ -435,6 +435,23 @@ void ProtocolTypeRepr::printImpl(ASTPrinter &Printer,
   Printer << ".Protocol";
 }
 
+SourceLoc OpaqueReturnParameterizedTypeRepr::getStartLocImpl() const {
+  return GenericParams->getLAngleLoc();
+}
+
+SourceLoc OpaqueReturnParameterizedTypeRepr::getEndLocImpl() const {
+  return Base->getEndLoc();
+}
+
+SourceLoc OpaqueReturnParameterizedTypeRepr::getLocImpl() const {
+  return Base->getLoc();
+}
+
+void OpaqueReturnParameterizedTypeRepr::printImpl(
+    ASTPrinter &Printer, const PrintOptions &Opts) const {
+  printTypeRepr(Base, Printer, Opts);
+}
+
 void OpaqueReturnTypeRepr::printImpl(ASTPrinter &Printer,
                                      const PrintOptions &Opts) const {
   Printer.printKeyword("some", Opts, /*Suffix=*/" ");

lib/Frontend/CompilerInvocation.cpp

@@ -420,6 +420,9 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   Opts.EnableExperimentalConcurrency |=
     Args.hasArg(OPT_enable_experimental_concurrency);
 
+  Opts.EnableExperimentalOpaqueReturnTypes |=
+      Args.hasArg(OPT_enable_experimental_opaque_return_types);
+
   Opts.EnableExperimentalDistributed |=
     Args.hasArg(OPT_enable_experimental_distributed);
 

lib/Parse/ParsePattern.cpp

@@ -17,6 +17,7 @@
 #include "swift/Parse/Parser.h"
 
 #include "swift/AST/ASTWalker.h"
+#include "swift/AST/GenericParamList.h"
 #include "swift/AST/Initializer.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/SourceFile.h"
@@ -823,7 +824,7 @@ Parser::parseFunctionArguments(SmallVectorImpl<Identifier> &NamePieces,
 ///   func-signature:
 ///     func-arguments ('async'|'reasync')? func-throws? func-signature-result?
 ///   func-signature-result:
-///     '->' type
+///     '->' generic-params? type
 ///
 /// Note that this leaves retType as null if unspecified.
 ParserStatus
@@ -864,17 +865,39 @@ Parser::parseFunctionSignature(Identifier SimpleName,
       arrowLoc = consumeToken(tok::colon);
     }
 
-    // Check for effect specifiers after the arrow, but before the type, and
-    // correct it.
+    // Check for effect specifiers after the arrow, but before the generic
+    // parameters, and correct it.
     parseEffectsSpecifiers(arrowLoc, asyncLoc, &reasync, throwsLoc, &rethrows);
 
+    GenericParamList *GenericParams = nullptr;
+    if (Context.LangOpts.EnableExperimentalOpaqueReturnTypes) {
+      auto GenericParamsResult = maybeParseGenericParams();
+      GenericParams = GenericParamsResult.getPtrOrNull();
+      Status |= GenericParamsResult;
+
+      // Check for effect specifiers after the generic parameters, but before
+      // the return type, and correct it.
+      parseEffectsSpecifiers(arrowLoc, asyncLoc, &reasync, throwsLoc,
+                             &rethrows);
+    }
+
     ParserResult<TypeRepr> ResultType =
         parseDeclResultType(diag::expected_type_function_result);
     retType = ResultType.getPtrOrNull();
     Status |= ResultType;
     if (Status.isErrorOrHasCompletion())
       return Status;
 
+    if (GenericParams != nullptr) {
+      // The `Base` for our `OpaqueReturnParameterizedTypeRepr` should not be
+      // `nullptr`
+      assert(
+          retType != nullptr &&
+          "Expected non-null return type if `parseDeclReturnType` succeeded");
+      retType = new (Context)
+          OpaqueReturnParameterizedTypeRepr(retType, GenericParams);
+    }
+
     // Check for effect specifiers after the type and correct it.
     parseEffectsSpecifiers(arrowLoc, asyncLoc, &reasync, throwsLoc, &rethrows);
   } else {