Implement basic support for opaque parameters.

Implement function parameters of the form `some P` be synthesizing an
implicit generic parameter whose requirements come from the opaque
type. We then map the opaque type back to the generic parameter, and
print as the opaque type. This allows us to write functions with
implicit generic parameters:

```swift
func f(_: some Collection) { }
```

which is equivalent to:

```swift
func f<T: Collection>(_: some T) { }
```

where `T` is an otherwise-unused generic parameter name.

All of this is behind the experimental frontend flag
`-enable-experimental-opaque-parameters`.

Author: DougGregor

include/swift/AST/Decl.h

@@ -2789,7 +2789,8 @@ class OpaqueTypeDecl final :
   /// Get the ordinal of the anonymous opaque parameter of this decl with type
   /// repr `repr`, as introduce implicitly by an occurrence of "some" in return
   /// position e.g. `func f() -> some P`. Returns -1 if `repr` is not found.
-  unsigned getAnonymousOpaqueParamOrdinal(OpaqueReturnTypeRepr *repr) const;
+  Optional<unsigned> getAnonymousOpaqueParamOrdinal(
+      OpaqueReturnTypeRepr *repr) const;
 
   GenericSignature getOpaqueInterfaceGenericSignature() const {
     return OpaqueInterfaceGenericSignature;

lib/AST/ASTPrinter.cpp

@@ -6031,7 +6031,8 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
   }
 
   void visitGenericTypeParamType(GenericTypeParamType *T) {
-    if (T->getDecl() == nullptr) {
+    auto decl = T->getDecl();
+    if (!decl) {
       // If we have an alternate name for this type, use it.
       if (Options.AlternativeTypeNames) {
         auto found = Options.AlternativeTypeNames->find(T->getCanonicalType());
@@ -6047,6 +6048,25 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
         T = Options.GenericSig->getSugaredType(T);
     }
 
+    // Print opaque types as "some ..."
+    if (decl && decl->isOpaqueType()) {
+      // If we have and should print based on the type representation, do so.
+      if (auto opaqueRepr = decl->getOpaqueTypeRepr()) {
+        if (willUseTypeReprPrinting(opaqueRepr, Type(), Options)) {
+          opaqueRepr->print(Printer, Options);
+          return;
+        }
+      }
+
+      // Print based on the type.
+      Printer << "some ";
+      if (auto inheritedType = decl->getInherited().front().getType())
+        inheritedType->print(Printer, Options);
+      else
+        Printer << "Any";
+      return;
+    }
+
     const auto Name = T->getName();
     if (Name.empty()) {
       Printer << "<anonymous>";

lib/AST/Decl.cpp

@@ -4113,7 +4113,7 @@ GenericTypeParamDecl::GenericTypeParamDecl(
   assert(Bits.GenericTypeParamDecl.Index == index && "Truncation");
   Bits.GenericTypeParamDecl.TypeSequence = isTypeSequence;
   Bits.GenericTypeParamDecl.IsOpaqueType = isOpaqueType;
-  assert(!isOpaqueType || !opaqueTypeRepr);
+  assert(isOpaqueType || !opaqueTypeRepr);
   if (isOpaqueType)
     *getTrailingObjects<OpaqueReturnTypeRepr *>() = opaqueTypeRepr;
 
@@ -7877,15 +7877,15 @@ GenericTypeParamDecl *OpaqueTypeDecl::getExplicitGenericParam(
   return genericParamType->getDecl();
 }
 
-unsigned OpaqueTypeDecl::getAnonymousOpaqueParamOrdinal(
+Optional<unsigned> OpaqueTypeDecl::getAnonymousOpaqueParamOrdinal(
     OpaqueReturnTypeRepr *repr) const {
   assert(NamingDeclAndHasOpaqueReturnTypeRepr.getInt() &&
          "can't do opaque param lookup without underlying interface repr");
   auto opaqueReprs = getOpaqueReturnTypeReprs();
   auto found = std::find(opaqueReprs.begin(), opaqueReprs.end(), repr);
   if (found != opaqueReprs.end())
     return found - opaqueReprs.begin();
-  return -1;
+  return None;
 }
 
 Identifier OpaqueTypeDecl::getOpaqueReturnTypeIdentifier() const {

lib/AST/NameLookup.cpp

@@ -2567,6 +2567,63 @@ createExtensionGenericParams(ASTContext &ctx,
   return toParams;
 }
 
+/// If there are opaque parameters in the given declaration, create the
+/// generic parameters associated with them.
+static SmallVector<GenericTypeParamDecl *, 2>
+createOpaqueParameterGenericParams(
+    GenericContext *genericContext, GenericParamList *parsedGenericParams) {
+  ASTContext &ctx = genericContext->getASTContext();
+  if (!ctx.LangOpts.EnableExperimentalOpaqueParameters)
+    return { };
+
+  auto value = dyn_cast_or_null<ValueDecl>(genericContext->getAsDecl());
+  if (!value)
+    return { };
+
+  // Functions, initializers, and subscripts can contain opaque parameters.
+  ParameterList *params = nullptr;
+  if (auto func = dyn_cast<AbstractFunctionDecl>(value))
+    params = func->getParameters();
+  else if (auto subscript = dyn_cast<SubscriptDecl>(value))
+    params = subscript->getIndices();
+  else
+    return { };
+
+  // Look for parameters that have "some" types in them.
+  unsigned index = parsedGenericParams ? parsedGenericParams->size() : 0;
+  SmallVector<GenericTypeParamDecl *, 2> implicitGenericParams;
+  auto dc = value->getInnermostDeclContext();
+  for (auto param : *params) {
+    // Don't permit variadic or inout parameters.
+    if (param->isVariadic() || param->isInOut())
+      continue;
+
+    auto typeRepr = param->getTypeRepr();
+    if (!typeRepr)
+      continue;
+
+    // FIXME: Do we want to allow any structure here? Optionals?
+    auto opaqueRepr = dyn_cast<OpaqueReturnTypeRepr>(typeRepr);
+    if (!opaqueRepr)
+      continue;
+
+    // Allocate a new generic parameter to represent this opaque type.
+    auto gp = GenericTypeParamDecl::create(
+        dc, Identifier(), SourceLoc(), /*isTypeSequence=*/false,
+        GenericTypeParamDecl::InvalidDepth, index++, /*isOpaqueType=*/true,
+        opaqueRepr);
+    gp->setImplicit();
+
+    // Use the underlying constraint as the constraint on the generic parameter.
+    InheritedEntry inherited[1] = { { TypeLoc(opaqueRepr->getConstraint()) } };
+    gp->setInherited(ctx.AllocateCopy(inherited));
+
+    implicitGenericParams.push_back(gp);
+  }
+
+  return implicitGenericParams;
+}
+
 GenericParamList *
 GenericParamListRequest::evaluate(Evaluator &evaluator, GenericContext *value) const {
   if (auto *ext = dyn_cast<ExtensionDecl>(value)) {
@@ -2619,7 +2676,35 @@ GenericParamListRequest::evaluate(Evaluator &evaluator, GenericContext *value) c
     return result;
   }
 
-  return value->getParsedGenericParams();
+  auto parsedGenericParams = value->getParsedGenericParams();
+
+  // Create implicit generic parameters due to opaque parameters, if we need
+  // them.
+  auto implicitGenericParams =
+      createOpaqueParameterGenericParams(value, parsedGenericParams);
+  if (implicitGenericParams.empty())
+    return parsedGenericParams;
+
+  // If there were no parsed generic parameters, create a fully-implicit
+  // generic parameter list.
+  ASTContext &ctx = value->getASTContext();
+  if (!parsedGenericParams) {
+    return GenericParamList::create(
+        ctx, SourceLoc(), implicitGenericParams, SourceLoc());
+  }
+
+  // Combine the existing generic parameters with the implicit ones.
+  SmallVector<GenericTypeParamDecl *, 4> allGenericParams;
+  allGenericParams.reserve(
+      parsedGenericParams->size() + implicitGenericParams.size());
+  allGenericParams.append(parsedGenericParams->begin(),
+                          parsedGenericParams->end());
+  allGenericParams.append(implicitGenericParams);
+  return GenericParamList::create(
+      ctx, parsedGenericParams->getLAngleLoc(), allGenericParams,
+      parsedGenericParams->getWhereLoc(),
+      parsedGenericParams->getRequirements(),
+      parsedGenericParams->getRAngleLoc());
 }
 
 NominalTypeDecl *

lib/Sema/TypeCheckType.cpp

@@ -2108,10 +2108,22 @@ NeverNullType TypeResolver::resolveType(TypeRepr *repr,
     // evaluation of an `OpaqueResultTypeRequest`.
     auto opaqueRepr = cast<OpaqueReturnTypeRepr>(repr);
     auto *DC = getDeclContext();
-    if (isa<OpaqueTypeDecl>(DC)) {
-      auto opaqueDecl = cast<OpaqueTypeDecl>(DC);
-      unsigned ordinal = opaqueDecl->getAnonymousOpaqueParamOrdinal(opaqueRepr);
-      return getIdentityOpaqueTypeArchetypeType(opaqueDecl, ordinal);
+    if (auto opaqueDecl = dyn_cast<OpaqueTypeDecl>(DC)) {
+      if (auto ordinal = opaqueDecl->getAnonymousOpaqueParamOrdinal(opaqueRepr))
+        return getIdentityOpaqueTypeArchetypeType(opaqueDecl, *ordinal);
+    }
+
+    // Check whether any of the generic parameters in the context represents
+    // this opaque type. If so, return that generic parameter.
+    if (auto declDC = DC->getAsDecl()) {
+      if (auto genericContext = declDC->getAsGenericContext()) {
+        if (auto genericParams = genericContext->getGenericParams()) {
+          for (auto genericParam : *genericParams) {
+            if (genericParam->getOpaqueTypeRepr() == opaqueRepr)
+              return genericParam->getDeclaredInterfaceType();
+          }
+        }
+      }
     }
 
     // We are not inside an `OpaqueTypeDecl`, so diagnose an error.

test/type/opaque_parameters.swift

@@ -0,0 +1,52 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-opaque-parameters -disable-availability-checking
+
+protocol P { }
+
+protocol Q {
+  associatedtype A: P & Equatable
+
+  func f() -> A
+}
+
+extension Int: P { }
+extension String: P { }
+
+// expected-note@+1{{requirement from conditional conformance of '[Double]' to 'Q'}}
+extension Array: Q where Element: P, Element: Equatable {
+  func f() -> Element {
+    return first!
+  }
+}
+
+extension Set: Q where Element: P, Element: Equatable {
+  func f() -> Element {
+    return first!
+  }
+}
+
+// expected-note@+2{{where 'some Q' = 'Int'}}
+// expected-note@+1{{in call to function 'takesQ'}}
+func takesQ(_ q: some Q) -> Bool {
+  return q.f() == q.f()
+}
+
+func testTakesQ(arrayOfInts: [Int], setOfStrings: Set<String>, i: Int) {
+  _ = takesQ(arrayOfInts)
+  _ = takesQ(setOfStrings)
+  _ = takesQ(i) // expected-error{{global function 'takesQ' requires that 'Int' conform to 'Q'}}
+
+  let f = takesQ // expected-error{{generic parameter 'some Q' could not be inferred}}
+  let _: ([String]) -> Bool = takesQ
+  let _: ([Double]) -> Bool = takesQ // expected-error{{global function 'takesQ' requires that 'Double' conform to 'P'}}
+  _ = f
+}
+
+// expected-note@+1{{where 'some P' = '[Int]'}}
+func takeMultiple<T>(_: T, _: some Q, _: some P) { }
+
+func testTakeMultiple(
+  arrayOfInts: [Int], setOfStrings: Set<String>, i: Int, d: Double
+) {
+  takeMultiple(d, arrayOfInts, i)
+  takeMultiple(d, arrayOfInts, arrayOfInts) // expected-error{{global function 'takeMultiple' requires that '[Int]' conform to 'P'}}
+}