[Named opaque types] Build a generic signature for named opaque types.

For a declaration that has a named opaque type, create a complete
generic signature describing the opaque type that includes the specified
generic parameters and any requirements within that generic parameter
list. This aligns the representation of named opaque types with
unnamed ('some P') opaque result types, so we get the same inference
behavior.

Introduce an egregious hack in type resolution to fake name lookup for
the generic parameters that are specified as part of a named opaque
type. This is to be replaced with the proper name lookup mechanism to
find those generic parameters, such that type resolution can turn them
into opaque type archetypes.

There are also a number of issues with structural opaque types
that are brought to the fore by named opaque types, especially the fact
that OpaqueTypeDecl does not retain the mapping from specific instances
of `some` to the corresponding (implicit) generic parameter, and
generally assumes that the underlying type of the OpaqueTypeDecl itself
is a generic type parameter. Addressing these shortcomings will benefit
both features.

Author: DougGregor

lib/AST/TypeRepr.cpp

@@ -98,9 +98,8 @@ bool TypeRepr::findIf(llvm::function_ref<bool(TypeRepr *)> pred) {
 // TODO [OPAQUE SUPPORT]: We should probably use something like `Type`'s
 // `RecursiveProperties` to track this instead of computing it.
 bool TypeRepr::hasOpaque() {
-  // TODO [OPAQUE SUPPORT]: In the future we will also need to check if `this`
-  // is a `NamedOpaqueReturnTypeRepr`.
-  return findIf([](TypeRepr *ty) { return isa<OpaqueReturnTypeRepr>(ty); });
+  return isa<NamedOpaqueReturnTypeRepr>(this) ||
+    findIf([](TypeRepr *ty) { return isa<OpaqueReturnTypeRepr>(ty); });
 }
 
 SourceLoc TypeRepr::findUncheckedAttrLoc() const {

lib/Sema/TypeCheckGeneric.cpp

@@ -178,93 +178,129 @@ OpaqueResultTypeRequest::evaluate(Evaluator &evaluator,
           ? outerGenericSignature.getGenericParams().back()->getDepth() + 1
           : 0;
 
-  SmallVector<GenericTypeParamType *, 2> genericParamTypes;
-  SmallVector<Requirement, 2> requirements;
-
-  auto opaqueReprs = collectOpaqueReturnTypeReprs(repr);
-  if (opaqueReprs.size() > 1) {
-    ctx.Diags.diagnose(repr->getLoc(), diag::more_than_one_opaque_type, repr);
-    return nullptr;
-  }
-
-  // TODO [OPAQUE SUPPORT]: right now we only allow one structural 'some' type,
-  // but *very* soon we will allow more than one such type.
-  for (unsigned i = 0; i < opaqueReprs.size(); ++i) {
-    auto *currentRepr = opaqueReprs[i];
-
-    // Usually, we resolve the opaque constraint and bail if it isn't a class or
-    // existential type (see below). However, in this case we know we will fail,
-    // so we can bail early and provide a better diagnostic.
-    if (auto *optionalRepr =
-            dyn_cast<OptionalTypeRepr>(currentRepr->getConstraint())) {
-      std::string buf;
-      llvm::raw_string_ostream stream(buf);
-      stream << "(some " << optionalRepr->getBase() << ")?";
-
-      ctx.Diags.diagnose(currentRepr->getLoc(),
-                         diag::opaque_type_invalid_constraint);
-      ctx.Diags
-          .diagnose(currentRepr->getLoc(), diag::opaque_of_optional_rewrite)
-          .fixItReplaceChars(currentRepr->getStartLoc(),
-                             currentRepr->getEndLoc(), stream.str());
+  // Determine the context of the opaque type declaration we'll be creating.
+  auto parentDC = originatingDecl->getDeclContext();
+  auto originatingGenericContext = originatingDecl->getAsGenericContext();
+  GenericParamList *genericParams;
+  GenericSignature interfaceSignature;
+
+  // FIXME: The generic parameter that serves as the underlying type of the
+  // opaque result type. This should become unnecessary, once we have fully
+  // implemented structural opaque result types.
+  GenericTypeParamType *underlyingGenericParamType;
+
+  CollectedOpaqueReprs opaqueReprs;
+  if (auto namedOpaque = dyn_cast<NamedOpaqueReturnTypeRepr>(repr)) {
+    // Produce the generic signature for the opaque type.
+    genericParams = namedOpaque->getGenericParams();
+    genericParams->setDepth(opaqueSignatureDepth);
+
+    InferredGenericSignatureRequest request{
+        originatingDC->getParentModule(),
+        outerGenericSignature.getPointer(),
+        genericParams,
+        WhereClauseOwner(originatingDC, genericParams),
+        /*addedRequirements=*/{},
+        /*inferenceSources=*/{},
+        /*allowConcreteGenericParams=*/false};
+
+    interfaceSignature = evaluateOrDefault(
+        ctx.evaluator, request, GenericSignatureWithError())
+          .getPointer();
+    if (!interfaceSignature) {
+      // Already produced an error.
       return nullptr;
     }
 
-    auto *paramType = GenericTypeParamType::get(/*type sequence*/ false,
-                                                opaqueSignatureDepth, i, ctx);
-    genericParamTypes.push_back(paramType);
-
-    // Try to resolve the constraint repr in the parent decl context. It should
-    // be some kind of existential type. Pass along the error type if resolving
-    // the repr failed.
-    auto constraintType = TypeResolution::forInterface(
-                              dc, TypeResolverContext::GenericRequirement,
-                              // Unbound generics and placeholders are
-                              // meaningless in opaque types.
-                              /*unboundTyOpener*/ nullptr,
-                              /*placeholderHandler*/ nullptr)
-                              .resolveType(currentRepr->getConstraint());
-
-    if (constraintType->hasError())
-      return nullptr;
-
-    // Error out if the constraint type isn't a class or existential type.
-    if (!constraintType->getClassOrBoundGenericClass() &&
-        !constraintType->isExistentialType()) {
-      ctx.Diags.diagnose(currentRepr->getLoc(),
-                         diag::opaque_type_invalid_constraint);
+    underlyingGenericParamType = interfaceSignature.getGenericParams()[0];
+  } else {
+    opaqueReprs = collectOpaqueReturnTypeReprs(repr);
+    if (opaqueReprs.size() > 1) {
+      ctx.Diags.diagnose(repr->getLoc(), diag::more_than_one_opaque_type, repr);
       return nullptr;
     }
 
-    if (constraintType->hasArchetype())
-      constraintType = constraintType->mapTypeOutOfContext();
+    // TODO [OPAQUE SUPPORT]: right now we only allow one structural 'some' type,
+    // but *very* soon we will allow more than one such type.
+    SmallVector<GenericTypeParamType *, 2> genericParamTypes;
+    SmallVector<Requirement, 2> requirements;
+    for (unsigned i = 0; i < opaqueReprs.size(); ++i) {
+      auto *currentRepr = opaqueReprs[i];
+
+      // Usually, we resolve the opaque constraint and bail if it isn't a class
+      // or existential type (see below). However, in this case we know we will
+      // fail, so we can bail early and provide a better diagnostic.
+      if (auto *optionalRepr =
+              dyn_cast<OptionalTypeRepr>(currentRepr->getConstraint())) {
+        std::string buf;
+        llvm::raw_string_ostream stream(buf);
+        stream << "(some " << optionalRepr->getBase() << ")?";
+
+        ctx.Diags.diagnose(currentRepr->getLoc(),
+                           diag::opaque_type_invalid_constraint);
+        ctx.Diags
+            .diagnose(currentRepr->getLoc(), diag::opaque_of_optional_rewrite)
+            .fixItReplaceChars(currentRepr->getStartLoc(),
+                               currentRepr->getEndLoc(), stream.str());
+        return nullptr;
+      }
 
-    if (constraintType->getClassOrBoundGenericClass()) {
-      requirements.push_back(
-          Requirement(RequirementKind::Superclass, paramType, constraintType));
-    } else {
-      // In this case, the constraint type is an existential
-      requirements.push_back(
-          Requirement(RequirementKind::Conformance, paramType, constraintType));
+      auto *paramType = GenericTypeParamType::get(/*type sequence*/ false,
+                                                  opaqueSignatureDepth, i, ctx);
+      genericParamTypes.push_back(paramType);
+
+      // Try to resolve the constraint repr in the parent decl context. It
+      // should be some kind of existential type. Pass along the error type if
+      // resolving the repr failed.
+      auto constraintType = TypeResolution::forInterface(
+                                dc, TypeResolverContext::GenericRequirement,
+                                // Unbound generics and placeholders are
+                                // meaningless in opaque types.
+                                /*unboundTyOpener*/ nullptr,
+                                /*placeholderHandler*/ nullptr)
+                                .resolveType(currentRepr->getConstraint());
+
+      if (constraintType->hasError())
+        return nullptr;
+
+      // Error out if the constraint type isn't a class or existential type.
+      if (!constraintType->getClassOrBoundGenericClass() &&
+          !constraintType->isExistentialType()) {
+        ctx.Diags.diagnose(currentRepr->getLoc(),
+                           diag::opaque_type_invalid_constraint);
+        return nullptr;
+      }
+
+      if (constraintType->hasArchetype())
+        constraintType = constraintType->mapTypeOutOfContext();
+
+      if (constraintType->getClassOrBoundGenericClass()) {
+        requirements.push_back(
+            Requirement(RequirementKind::Superclass, paramType,
+                        constraintType));
+      } else {
+        // In this case, the constraint type is an existential
+        requirements.push_back(
+            Requirement(RequirementKind::Conformance, paramType,
+                        constraintType));
+      }
     }
-  }
 
-  auto interfaceSignature = buildGenericSignature(ctx, outerGenericSignature,
-                                                  genericParamTypes,
-                                                  std::move(requirements));
+    interfaceSignature = buildGenericSignature(ctx, outerGenericSignature,
+                                               genericParamTypes,
+                                               std::move(requirements));
+    genericParams = originatingGenericContext
+        ? originatingGenericContext->getGenericParams()
+        : nullptr;
+    underlyingGenericParamType = genericParamTypes[0];
+  }
 
   // Create the OpaqueTypeDecl for the result type.
-  // It has the same parent context and generic environment as the originating
-  // decl.
-  auto parentDC = originatingDecl->getDeclContext();
-  auto originatingGenericContext = originatingDecl->getAsGenericContext();
-  GenericParamList *genericParams = originatingGenericContext
-    ? originatingGenericContext->getGenericParams()
-    : nullptr;
-
   auto opaqueDecl = new (ctx)
       OpaqueTypeDecl(originatingDecl, genericParams, parentDC,
-                     interfaceSignature, opaqueReprs[0], genericParamTypes[0]);
+                     interfaceSignature,
+                     opaqueReprs.empty() ? 0 : opaqueReprs[0],
+                     underlyingGenericParamType);
   opaqueDecl->copyFormalAccessFrom(originatingDecl);
   if (auto originatingSig = originatingDC->getGenericSignatureOfContext()) {
     opaqueDecl->setGenericSignature(originatingSig);

lib/Sema/TypeCheckType.cpp

@@ -2084,9 +2084,47 @@ NeverNullType TypeResolver::resolveType(TypeRepr *repr,
     return resolveExistentialType(existential, options);
   }
 
-  case TypeReprKind::NamedOpaqueReturn:
-    return resolveType(cast<NamedOpaqueReturnTypeRepr>(repr)->getBase(),
-                       options);
+  case TypeReprKind::NamedOpaqueReturn: {
+    // If the named opaque result type is in a valid position, resolution
+    // should happen in the context of an `OpaqueTypeDecl`. This decl is
+    // implicit in the source and is created in such contexts by evaluation of
+    // an `OpaqueResultTypeRequest`.
+    auto opaqueRepr = cast<NamedOpaqueReturnTypeRepr>(repr);
+    if (auto opaqueDecl = dyn_cast<OpaqueTypeDecl>(getDeclContext())) {
+      // Resolve the base type within this context.
+
+      // FIXME: Temporary hack to resolve an identifier type to one of the
+      // generic parameters of the opaque return type. This should be subsumed
+      // be proper name lookup, OF COURSE.
+      if (auto simpleIdent = dyn_cast<SimpleIdentTypeRepr>(
+              opaqueRepr->getBase())) {
+        Identifier name = simpleIdent->getComponentRange().front()
+            ->getNameRef().getBaseIdentifier();
+        if (auto gpDecl = opaqueRepr->getGenericParams()
+                ->lookUpGenericParam(name)) {
+          auto outerGenericSignature = opaqueDecl->getNamingDecl()
+                                           ->getInnermostDeclContext()
+                                           ->getGenericSignatureOfContext();
+
+          SubstitutionMap subs;
+          if (outerGenericSignature)
+            subs = outerGenericSignature->getIdentitySubstitutionMap();
+
+          return OpaqueTypeArchetypeType::get(
+                            opaqueDecl, gpDecl->getIndex(), subs);
+        }
+      }
+
+      return resolveType(opaqueRepr->getBase(), options);
+    }
+
+    // We are not inside an `OpaqueTypeDecl`, so diagnose an error.
+    if (!(options & TypeResolutionFlags::SilenceErrors)) {
+      diagnose(repr->getStartLoc(), diag::unsupported_opaque_type);
+    }
+
+    return ErrorType::get(getASTContext());
+  }
 
   case TypeReprKind::Placeholder: {
     auto &ctx = getASTContext();

test/type/opaque_return_named.swift

@@ -2,18 +2,45 @@
 
 // Tests for experimental extensions to opaque return type support.
 
-func f0() -> <T> () { }
-func f1() -> <T, U, V> () { }
-func f2() -> <T: Collection, U: SignedInteger> () { }
-func f4() async -> <T> () { }
+func f0() -> <T> T { return () }
+func f1() -> <T, U, V> T { () }
+// FIXME better diagnostic: expected-error@-1{{generic parameter 'U' could not be inferred}}
+// FIXME better diagnostic: expected-error@-2{{generic parameter 'V' could not be inferred}}
+func f2() -> <T: Collection, U: SignedInteger> T { // expected-note{{required by opaque return type of global function 'f2()'}}
+  () // expected-error{{type '()' cannot conform to 'Collection'}}
+  // expected-note@-1{{only concrete types such as structs, enums and classes can conform to protocols}}
+  // expected-error@-2{{generic parameter 'U' could not be inferred}}
+}
+
+func f4() async -> <T> T { () }
 
 func g0() -> <T> { } // expected-error{{expected type for function result}}
-func g1() -> async <T> () { } // expected-error{{'async' may only occur before '->'}}
-func g2() -> <T> () async { } // expected-error{{'async' may only occur before '->'}}
+func g1() -> async <T> T { () } // expected-error{{'async' may only occur before '->'}}
+func g2() -> <T> T async { () } // expected-error{{'async' may only occur before '->'}}
 
 let x0: <T> Int = 1
 var x1: <T> (Int, Int) = (1, 1)
 var x2: <T> (<U> Int, Int) = (1, 1) // expected-error{{expected type}} expected-error{{cannot convert value of type '(Int, Int)' to specified type 'Int'}}
-for _: <T> Int in [1, 2, 3] { }
+for _: <T> Int in [1, 2, 3] { } // FIXME mention of 'some' is wrong: expected-error{{some' type can only be declared on a single property declaration}}
+
+struct S0 { subscript(i: Int) -> <T> T { 1 } }
+
+protocol P { }
+extension Int: P { }
+
+protocol Q { }
+
+func h0() -> <T: P> T { 5 }
+
+func h1() -> <T: P> T { // expected-note{{opaque return type declared here}}
+  3.14159 // expected-error{{return type of global function 'h1()' requires that 'Double' conform to 'P'}}
+}
+
+func h2() -> <T: P & Q> T { // expected-note{{opaque return type declared here}}
+  3 // expected-error{{return type of global function 'h2()' requires that 'Int' conform to 'Q'}}
+}
 
-struct S0 { subscript(i: Int) -> <T> Int { 1 } }
+func test_h0() {
+  // Make sure we can treat h0 as a P
+  let _: P = h0()
+}