Implement most of the semantic analysis for named opaque result types.

Address small gaps in several places to make named opaque result types
partially work:

* Augment name lookup to look into the generic parameters when inside the
result type, which is used both to create structure and add requirements
via a `where` clause.
* Resolve opaque generic type parameter references to
OpaqueTypeArchetypeType instances, as we do for the "some" types
* Customize some opaque-type-specific diagnostics and type printing to
refer to the opaque generic parameter names specifically
* Fix some minor issues with the constraint system not finding
already-opened opaque generic type parameters and with the handling of
the opaque result type candidate set.

The major limitation on opaque types, where we cannot add requirements
that aren't strictly protocol or superclass requirements on the
generic parameters, remains. Until then, named opaque result types are
no more expressive than structural opaque result types.

Author: DougGregor

include/swift/AST/Decl.h

@@ -2779,6 +2779,16 @@ class OpaqueTypeDecl final :
     return OpaqueInterfaceGenericSignature.getInnermostGenericParams();
   }
 
+  /// Whether the generic parameters of this opaque type declaration were
+  /// explicit, i.e., for named opaque result types.
+  bool hasExplicitGenericParams() const;
+
+  /// When the generic parameters were explicit, returns the generic parameter
+  /// corresponding to the given ordinal.
+  ///
+  /// Otherwise, returns \c nullptr.
+  GenericTypeParamDecl *getExplicitGenericParam(unsigned ordinal) const;
+
   /// Retrieve the buffer containing the opaque return type
   /// representations that correspond to the opaque generic parameters.
   ArrayRef<OpaqueReturnTypeRepr *> getOpaqueReturnTypeReprs() const {

include/swift/AST/DiagnosticsSema.def

@@ -4134,6 +4134,9 @@ ERROR(opaque_type_no_underlying_type_candidates,none,
 ERROR(opaque_type_mismatched_underlying_type_candidates,none,
       "function declares an opaque return type %0, but the return statements "
       "in its body do not have matching underlying types", (TypeRepr *))
+ERROR(opaque_type_mismatched_underlying_type_candidates_named,none,
+      "function declares an opaque return type %0, but the return statements "
+      "in its body do not have matching underlying types", (Identifier))
 NOTE(opaque_type_underlying_type_candidate_here,none,
      "return statement has underlying type %0", (Type))
 ERROR(opaque_type_self_referential_underlying_type,none,

lib/AST/ASTPrinter.cpp

@@ -4338,9 +4338,10 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       case PrintOptions::OpaqueReturnTypePrintingMode::Description:
         return true;
       case PrintOptions::OpaqueReturnTypePrintingMode::WithOpaqueKeyword:
-        return false;
+        return opaque->getDecl()->hasExplicitGenericParams();
       case PrintOptions::OpaqueReturnTypePrintingMode::WithoutOpaqueKeyword:
-        return isSimpleUnderPrintOptions(opaque->getExistentialType());
+        return opaque->getDecl()->hasExplicitGenericParams() ||
+            isSimpleUnderPrintOptions(opaque->getExistentialType());
       }
       llvm_unreachable("bad opaque-return-type printing mode");
     }
@@ -5410,11 +5411,28 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
   }
 
   void visitOpaqueTypeArchetypeType(OpaqueTypeArchetypeType *T) {
+    // Try to print a named opaque type.
+    auto printNamedOpaque = [&] {
+      if (auto genericParam =
+              T->getDecl()->getExplicitGenericParam(T->getOrdinal())) {
+        visit(genericParam->getDeclaredInterfaceType());
+        return true;
+      }
+
+      return false;
+    };
+
     switch (Options.OpaqueReturnTypePrinting) {
     case PrintOptions::OpaqueReturnTypePrintingMode::WithOpaqueKeyword:
+      if (printNamedOpaque())
+        return;
+
       Printer.printKeyword("some", Options, /*Suffix=*/" ");
       LLVM_FALLTHROUGH;
     case PrintOptions::OpaqueReturnTypePrintingMode::WithoutOpaqueKeyword: {
+      if (printNamedOpaque())
+        return;
+
       visit(T->getExistentialType());
       return;
     }

lib/AST/ASTScopeCreation.cpp

@@ -859,6 +859,13 @@ void AbstractFunctionDeclScope::expandAScopeThatDoesNotCreateANewInsertionPoint(
   ASTScopeImpl *leaf = this;
 
   if (!isa<AccessorDecl>(decl)) {
+    if (auto opaqueRepr = decl->getOpaqueResultTypeRepr()) {
+      if (auto namedOpaque = dyn_cast<NamedOpaqueReturnTypeRepr>(opaqueRepr)) {
+        leaf = scopeCreator.addNestedGenericParamScopesToTree(
+            decl, namedOpaque->getGenericParams(), leaf);
+      }
+    }
+
     leaf = scopeCreator.addNestedGenericParamScopesToTree(
         decl, decl->getGenericParams(), leaf);
 

lib/AST/Decl.cpp

@@ -7829,6 +7829,19 @@ bool OpaqueTypeDecl::isOpaqueReturnTypeOfFunction(
   return false;
 }
 
+bool OpaqueTypeDecl::hasExplicitGenericParams() const {
+  return getExplicitGenericParam(0) != nullptr;
+}
+
+GenericTypeParamDecl *OpaqueTypeDecl::getExplicitGenericParam(
+    unsigned ordinal) const {
+  if (ordinal >= getOpaqueGenericParams().size())
+    return nullptr;
+
+  auto genericParamType = getOpaqueGenericParams()[ordinal];
+  return genericParamType->getDecl();
+}
+
 unsigned OpaqueTypeDecl::getAnonymousOpaqueParamOrdinal(
     OpaqueReturnTypeRepr *repr) const {
   assert(NamingDeclAndHasOpaqueReturnTypeRepr.getInt() &&

lib/Sema/ConstraintSystem.cpp

@@ -846,7 +846,7 @@ Type ConstraintSystem::openOpaqueType(OpaqueTypeArchetypeType *opaque,
   if (knownReplacements != OpenedTypes.end()) {
     auto param = opaque->getInterfaceType()->castTo<GenericTypeParamType>();
     for (const auto &replacement : knownReplacements->second) {
-      if (replacement.first == param)
+      if (replacement.first->isEqual(param))
         return replacement.second;
     }
 

lib/Sema/MiscDiagnostics.cpp

@@ -2610,6 +2610,7 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
   OpaqueTypeDecl *OpaqueDecl;
   BraceStmt *Body;
   SmallVector<Candidate, 4> Candidates;
+  SmallPtrSet<const void *, 4> KnownCandidates;
 
   bool HasInvalidReturn = false;
 
@@ -2644,13 +2645,7 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
     // Check whether all of the underlying type candidates match up.
     // TODO [OPAQUE SUPPORT]: diagnose multiple opaque types
     SubstitutionMap underlyingSubs = Candidates.front().second;
-    SubstitutionMap canonicalUnderlyingSubs = underlyingSubs.getCanonical();
-    bool mismatch =
-        std::any_of(Candidates.begin() + 1, Candidates.end(),
-                    [&](Candidate &otherCandidate) {
-                      return canonicalUnderlyingSubs != otherCandidate.second.getCanonical();
-                    });
-    if (mismatch) {
+    if (Candidates.size() > 1) {
       unsigned mismatchIndex = OpaqueDecl->getOpaqueGenericParams().size();
       for (auto genericParam : OpaqueDecl->getOpaqueGenericParams()) {
         unsigned index = genericParam->getIndex();
@@ -2669,12 +2664,21 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
           break;
       }
       assert(mismatchIndex < OpaqueDecl->getOpaqueGenericParams().size());
-      TypeRepr *opaqueRepr =
-          OpaqueDecl->getOpaqueReturnTypeReprs()[mismatchIndex];
-      Implementation->diagnose(
-          diag::opaque_type_mismatched_underlying_type_candidates,
-          opaqueRepr)
-        .highlight(opaqueRepr->getSourceRange());
+
+      if (auto genericParam =
+              OpaqueDecl->getExplicitGenericParam(mismatchIndex)) {
+        Implementation->diagnose(
+            diag::opaque_type_mismatched_underlying_type_candidates_named,
+            genericParam->getName())
+          .highlight(genericParam->getLoc());
+      } else {
+        TypeRepr *opaqueRepr =
+            OpaqueDecl->getOpaqueReturnTypeReprs()[mismatchIndex];
+        Implementation->diagnose(
+            diag::opaque_type_mismatched_underlying_type_candidates,
+            opaqueRepr)
+          .highlight(opaqueRepr->getSourceRange());
+      }
 
       for (auto candidate : Candidates) {
         Ctx.Diags.diagnose(
@@ -2712,8 +2716,12 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
 
   std::pair<bool, Expr *> walkToExprPre(Expr *E) override {
     if (auto underlyingToOpaque = dyn_cast<UnderlyingToOpaqueExpr>(E)) {
-      Candidates.push_back(std::make_pair(underlyingToOpaque->getSubExpr(),
-                                          underlyingToOpaque->substitutions));
+      auto key =
+          underlyingToOpaque->substitutions.getCanonical().getOpaqueValue();
+      if (KnownCandidates.insert(key).second) {
+        Candidates.push_back(std::make_pair(underlyingToOpaque->getSubExpr(),
+                                            underlyingToOpaque->substitutions));
+      }
       return {false, E};
     }
     return {true, E};

lib/Sema/TypeCheckType.cpp

@@ -284,6 +284,20 @@ TypeChecker::getDynamicBridgedThroughObjCClass(DeclContext *dc,
   return dc->getASTContext().getBridgedToObjC(dc, valueType);
 }
 
+/// Retrieve the identity form of the opaque type archetype type.
+static OpaqueTypeArchetypeType *getIdentityOpaqueTypeArchetypeType(
+    OpaqueTypeDecl *opaqueDecl, unsigned ordinal) {
+  auto outerGenericSignature = opaqueDecl->getNamingDecl()
+                                   ->getInnermostDeclContext()
+                                   ->getGenericSignatureOfContext();
+
+  SubstitutionMap subs;
+  if (outerGenericSignature)
+    subs = outerGenericSignature->getIdentitySubstitutionMap();
+
+  return OpaqueTypeArchetypeType::get(opaqueDecl, ordinal, subs);
+}
+
 Type TypeResolution::resolveTypeInContext(TypeDecl *typeDecl,
                                           DeclContext *foundDC,
                                           bool isSpecialized) const {
@@ -292,6 +306,16 @@ Type TypeResolution::resolveTypeInContext(TypeDecl *typeDecl,
 
   // If we found a generic parameter, map to the archetype if there is one.
   if (auto genericParam = dyn_cast<GenericTypeParamDecl>(typeDecl)) {
+    // If this generic parameter is for an opaque type, map to the opened
+    // archetype.
+    if (auto opaqueDecl = dyn_cast<OpaqueTypeDecl>(getDeclContext())) {
+      if (genericParam->getDepth() ==
+              opaqueDecl->getOpaqueGenericParams().front()->getDepth()) {
+        return getIdentityOpaqueTypeArchetypeType(
+            opaqueDecl, genericParam->getIndex());
+      }
+    }
+
     return genericParam->getDeclaredInterfaceType();
   }
 
@@ -2047,16 +2071,8 @@ NeverNullType TypeResolver::resolveType(TypeRepr *repr,
     auto *DC = getDeclContext();
     if (isa<OpaqueTypeDecl>(DC)) {
       auto opaqueDecl = cast<OpaqueTypeDecl>(DC);
-      auto outerGenericSignature = opaqueDecl->getNamingDecl()
-                                       ->getInnermostDeclContext()
-                                       ->getGenericSignatureOfContext();
-
-      SubstitutionMap subs;
-      if (outerGenericSignature)
-        subs = outerGenericSignature->getIdentitySubstitutionMap();
-
       unsigned ordinal = opaqueDecl->getAnonymousOpaqueParamOrdinal(opaqueRepr);
-      return OpaqueTypeArchetypeType::get(opaqueDecl, ordinal, subs);
+      return getIdentityOpaqueTypeArchetypeType(opaqueDecl, ordinal);
     }
 
     // We are not inside an `OpaqueTypeDecl`, so diagnose an error.

test/type/opaque_return_named.swift

@@ -44,3 +44,76 @@ func test_h0() {
   // Make sure we can treat h0 as a P
   let _: P = h0()
 }
+
+protocol P1 {
+  associatedtype A
+}
+
+protocol Q1 {
+  associatedtype B
+}
+
+extension Int: P1 {
+  typealias A = String
+}
+
+extension String: P1 {
+  typealias A = String
+}
+
+extension Double: Q1 {
+  typealias B = String
+}
+
+extension String: Q1 {
+  typealias B = Int
+}
+
+func f1() -> <T: P1, U where U: Q1> (T, U) {
+  return (3, 3.14159)
+}
+
+func f2(cond: Bool) -> <T: P1, U where U: Q1> (T, U) {
+  if cond {
+    return (3, 3.14159)
+  } else {
+    return (3, 2.71828)
+  }
+}
+
+func f3(cond: Bool) -> <T: P1, U where U: Q1> (T, U) {
+  // expected-error@-1{{function declares an opaque return type 'U', but the return statements in its body do not have matching underlying types}}
+  if cond {
+    return (3, 3.14159) // expected-note{{return statement has underlying type 'Double'}}
+  } else {
+    return (3, "hello") // expected-note{{return statement has underlying type 'String'}}
+  }
+}
+
+func f4(cond: Bool) -> <T: P1, U where U: Q1> (T, U) {
+  if cond {
+    return (3, 3.14159)
+  } else {
+  }
+}
+
+func f5(cond: Bool) -> <T: P1, U where U: Q1> (T, U) { }
+// expected-error@-1{{function declares an opaque return type, but has no return statements in its body from which to infer an underlying type}}
+
+struct Generic<T: P1 & Equatable> {
+  var value: T
+
+  func f() -> <U: Q1, V: P1 where U: Equatable, V: Equatable> (U, V) {
+    return ("hello", value)
+  }
+}
+
+func testGeneric(gs: Generic<String>, gi: Generic<Int>) {
+  let gs1 = gs.f()
+  let gs2 = gs.f()
+  _ = (gs1 == gs2)
+
+  let gi1 = gi.f()
+  // FIXME: Diagnostic below is correct, but a bit misleading because these are different Us and Vs.
+  _ = (gs1 == gi1) // expected-error{{binary operator '==' cannot be applied to operands of type '(U, V)' and '(U, V)'}}
+}