[NameLookup] Collect implicit opaque GenericParams

Plain protocols with generic type paramters should
be collected as opaque types.

Author: angela-laar

include/swift/AST/TypeRepr.h

@@ -125,7 +125,7 @@ class alignas(1 << TypeReprAlignInBits) TypeRepr
   }
 
   /// Is this type representation a protocol?
-  bool isProtocol(DeclContext *dc);
+  bool isProtocolOrProtocolComposition(DeclContext *dc);
 
   /// Is this type representation known to be invalid?
   bool isInvalid() const { return Bits.TypeRepr.Invalid; }
@@ -408,6 +408,7 @@ class GenericIdentTypeRepr final
     return {getTrailingObjects<TypeRepr*>(),
             Bits.GenericIdentTypeRepr.NumGenericArgs};
   }
+
   SourceRange getAngleBrackets() const { return AngleBrackets; }
 
   static bool classof(const TypeRepr *T) {

lib/AST/NameLookup.cpp

@@ -2924,7 +2924,7 @@ static bool declsAreAssociatedTypes(ArrayRef<TypeDecl *> decls) {
 /// Verify there is at least one protocols in the set of declarations.
 static bool declsAreProtocols(ArrayRef<TypeDecl *> decls) {
   if (decls.empty())
-    return false;
+    return false;  // Below, check outer type repr is a protocol, if not bail early
   return llvm::any_of(decls, [&](const TypeDecl *decl) {
     if (auto *alias = dyn_cast<TypeAliasDecl>(decl)) {
       auto ty = alias->getUnderlyingType();
@@ -2933,14 +2933,12 @@ static bool declsAreProtocols(ArrayRef<TypeDecl *> decls) {
         return false;
     }
     return isa<ProtocolDecl>(decl);
-  });;;
+  });
 }
 
-bool TypeRepr::isProtocol(DeclContext *dc){
+bool TypeRepr::isProtocolOrProtocolComposition(DeclContext *dc){
   auto &ctx = dc->getASTContext();
-  return findIf([&ctx, dc](TypeRepr *ty) {
-    return declsAreProtocols(directReferencesForTypeRepr(ctx.evaluator, ctx, ty, dc));
-  });
+    return declsAreProtocols(directReferencesForTypeRepr(ctx.evaluator, ctx, this, dc));
 }
 
 static GenericParamList *
@@ -2993,15 +2991,19 @@ CollectedOpaqueReprs swift::collectOpaqueReturnTypeReprs(TypeRepr *r, ASTContext
 
       if (auto existential = dyn_cast<ExistentialTypeRepr>(repr)) {
         return Action::SkipChildren();
-      } else if (auto compositionRepr = dyn_cast<CompositionTypeRepr>(repr)) {
-        if (!compositionRepr->isTypeReprAny())
-          Reprs.push_back(compositionRepr);
+      } else if (auto composition = dyn_cast<CompositionTypeRepr>(repr)) {
+        if (!composition->isTypeReprAny())
+          Reprs.push_back(composition);
         return Action::SkipChildren();
       } else if (auto generic = dyn_cast<GenericIdentTypeRepr>(repr)) {
+        if (generic->isProtocolOrProtocolComposition(dc)){
+          Reprs.push_back(generic);
+          return Action::SkipChildren();
+        }
         return Action::Continue();
-      } else if (auto declRefTR = dyn_cast<DeclRefTypeRepr>(repr)) {
-        if (declRefTR->isProtocol(dc))
-          Reprs.push_back(declRefTR);
+      } else if (auto declRef = dyn_cast<DeclRefTypeRepr>(repr)) {
+        if (declRef->isProtocolOrProtocolComposition(dc))
+          Reprs.push_back(declRef);
       }
       return Action::Continue();
     }