[Sema] Resolve ident type to opaque result type

This is just more work to get type resolution to understand
how to derive an opaque type from an IdentTypeRepr during
OpaqueResultTypeRequest

Author: angela-laar

include/swift/AST/Decl.h

@@ -2904,7 +2904,7 @@ class OpaqueTypeDecl final :
   /// 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.
   Optional<unsigned> getAnonymousOpaqueParamOrdinal(
-      OpaqueReturnTypeRepr *repr) const;
+      TypeRepr *repr) const;
 
   GenericSignature getOpaqueInterfaceGenericSignature() const {
     return OpaqueInterfaceGenericSignature;

lib/AST/Decl.cpp

@@ -3053,8 +3053,13 @@ TypeRepr *ValueDecl::getOpaqueResultTypeRepr() const {
     returnRepr = SD->getElementTypeRepr();
   }
 
+  auto *dc = getDeclContext();
+  auto &ctx = dc->getASTContext();
+  
   if (returnRepr && returnRepr->hasOpaque()) {
     return returnRepr;
+  } else if (returnRepr && ctx.LangOpts.hasFeature(Feature::ImplicitSome) && returnRepr->isProtocol(dc)) {
+    return returnRepr;
   } else {
     return nullptr;
   }
@@ -8315,7 +8320,7 @@ GenericTypeParamDecl *OpaqueTypeDecl::getExplicitGenericParam(
 }
 
 Optional<unsigned> OpaqueTypeDecl::getAnonymousOpaqueParamOrdinal(
-    OpaqueReturnTypeRepr *repr) const {
+    TypeRepr *repr) const {
   assert(NamingDeclAndHasOpaqueReturnTypeRepr.getInt() &&
          "can't do opaque param lookup without underlying interface repr");
   auto opaqueReprs = getOpaqueReturnTypeReprs();

lib/AST/NameLookup.cpp

@@ -2765,16 +2765,11 @@ static bool declsAreAssociatedTypes(ArrayRef<TypeDecl *> decls) {
   return true;
 }
 
-/// Verify there are only protocols in the set of declarations.
+/// Verify there is at least one protocols in the set of declarations.
 static bool declsAreProtocols(ArrayRef<TypeDecl *> decls) {
   if (decls.empty())
     return false;
-
-  for (auto decl : decls) {
-    if (!isa<ProtocolDecl>(decl))
-        return false;
-  }
-  return true;
+  return llvm::any_of(decls, [&](const TypeDecl *decl) { return isa<ProtocolDecl>(decl); });;;
 }
 
 bool TypeRepr::isProtocol(DeclContext *dc){
@@ -2816,16 +2811,17 @@ CollectedOpaqueReprs swift::collectOpaqueReturnTypeReprs(TypeRepr *r, ASTContext
         return false;
       }
 
-      if (auto opaqueRepr = dyn_cast<OpaqueReturnTypeRepr>(repr)){
+      if (auto opaqueRepr = dyn_cast<OpaqueReturnTypeRepr>(repr)) {
         Reprs.push_back(opaqueRepr);
         if (Ctx.LangOpts.hasFeature(Feature::ImplicitSome))
           return false;
       }
 
-      if (Ctx.LangOpts.hasFeature(Feature::ImplicitSome)){
-        if (auto compositionRepr = dyn_cast<CompositionTypeRepr>(repr)){
+      if (Ctx.LangOpts.hasFeature(Feature::ImplicitSome)) {
+        if (auto compositionRepr = dyn_cast<CompositionTypeRepr>(repr)) {
           if (!compositionRepr->isTypeReprAny())
             Reprs.push_back(compositionRepr);
+          return false;
         } else if (auto identRepr = dyn_cast<IdentTypeRepr>(repr)) {
           if (identRepr->isProtocol(dc))
             Reprs.push_back(identRepr);

lib/Sema/TypeCheckGeneric.cpp

@@ -167,7 +167,7 @@ OpaqueResultTypeRequest::evaluate(Evaluator &evaluator,
       genericParamTypes.push_back(paramType);
 
       TypeRepr *constraint = currentRepr;
-      //auto constraint = currentRepr;
+      //auto *constraint = currentRepr;
 
       if (auto opaqueReturn = dyn_cast<OpaqueReturnTypeRepr>(currentRepr)){
         constraint = opaqueReturn->getConstraint();

lib/Sema/TypeCheckType.cpp

@@ -2243,8 +2243,30 @@ NeverNullType TypeResolver::resolveType(TypeRepr *repr,
                                              options);
   case TypeReprKind::SimpleIdent:
   case TypeReprKind::GenericIdent:
-  case TypeReprKind::CompoundIdent:
-    return resolveIdentifierType(cast<IdentTypeRepr>(repr), options);
+  case TypeReprKind::CompoundIdent: {
+    auto *DC = getDeclContext();
+    auto diagnoseDisallowedExistential = [&](Type ty) {
+      if (!(options & TypeResolutionFlags::SilenceErrors) &&
+          options.contains(TypeResolutionFlags::DisallowOpaqueTypes)) {
+        // We're specifically looking at an existential type `any P<some Q>`,
+        // so emit a tailored diagnostic. We don't emit an ErrorType here
+        // for better recovery.
+        diagnose(repr->getLoc(),
+                 diag::unsupported_opaque_type_in_existential);
+        // FIXME: We shouldn't have to invalid the type repr here, but not
+        // doing so causes a double-diagnostic.
+        repr->setInvalid();
+      }
+      return ty;
+    };
+    
+      if (auto opaqueDecl = dyn_cast<OpaqueTypeDecl>(DC)) {
+        if (auto ordinal = opaqueDecl->getAnonymousOpaqueParamOrdinal(repr))
+          return diagnoseDisallowedExistential(getIdentityOpaqueTypeArchetypeType(opaqueDecl, *ordinal));
+      } else {
+        return resolveIdentifierType(cast<IdentTypeRepr>(repr), options);
+      }
+  }
 
   case TypeReprKind::Function: {
     if (!(options & TypeResolutionFlags::SILType)) {
@@ -3825,7 +3847,7 @@ TypeResolver::resolveIdentifierType(IdentTypeRepr *IdType,
     auto *dc = getDeclContext();
     auto &ctx = getASTContext();
 
-    if ( ctx.LangOpts.hasFeature(Feature::ImplicitSome) & !options.is(TypeResolverContext::Inherited) ){
+    if (ctx.LangOpts.hasFeature(Feature::ImplicitSome) && options.isConstraintImplicitExistential()) {
       // 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()) {