[Sema] Support GenericIdentTypeReprs as opaque parameters and return type

Author: angela-laar

lib/AST/NameLookup.cpp

@@ -2808,9 +2808,13 @@ CollectedOpaqueReprs swift::collectOpaqueReturnTypeReprs(TypeRepr *r, ASTContext
 
     bool walkToTypeReprPre(TypeRepr *repr) override {
       if (auto existential = dyn_cast<ExistentialTypeRepr>(repr)) {
-        return false;
+        auto generic = dyn_cast<GenericIdentTypeRepr>(existential->getConstraint());
+        if(generic)
+          Reprs.push_back(existential);
+        auto meta = dyn_cast<MetatypeTypeRepr>(existential->getConstraint());
+        return meta || generic?  true : false;
       }
-      
+
       if (auto opaqueRepr = dyn_cast<OpaqueReturnTypeRepr>(repr)) {
         Reprs.push_back(opaqueRepr);
         if (Ctx.LangOpts.hasFeature(Feature::ImplicitSome))
@@ -2822,6 +2826,14 @@ CollectedOpaqueReprs swift::collectOpaqueReturnTypeReprs(TypeRepr *r, ASTContext
           if (!compositionRepr->isTypeReprAny())
             Reprs.push_back(compositionRepr);
           return false;
+        } else if (auto generic = dyn_cast<GenericIdentTypeRepr>(repr)) {
+          if (!Reprs.empty()){
+            if(isa<ExistentialTypeRepr>(Reprs.front())){
+              Reprs.clear();
+              return true;
+            }
+          }
+          Reprs.push_back(generic);
         } else if (auto identRepr = dyn_cast<IdentTypeRepr>(repr)) {
           if (identRepr->isProtocol(dc))
             Reprs.push_back(identRepr);

lib/Sema/TypeCheckType.cpp

@@ -2259,13 +2259,29 @@ NeverNullType TypeResolver::resolveType(TypeRepr *repr,
       }
       return ty;
     };
+
+    if (auto opaqueDecl = dyn_cast<OpaqueTypeDecl>(DC)) {
+      if (auto ordinal = opaqueDecl->getAnonymousOpaqueParamOrdinal(repr))
+        return diagnoseDisallowedExistential(getIdentityOpaqueTypeArchetypeType(opaqueDecl, *ordinal));
+    }
 
-      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);
+    // Check whether any of the generic parameters in the context represents
+    // this opaque type. If so, return that generic parameter.
+    if (options.isConstraintImplicitExistential()) {
+      if (auto declDC = DC->getAsDecl()) {
+        if (auto genericContext = declDC->getAsGenericContext()) {
+          if (auto genericParams = genericContext->getGenericParams()) {
+            for (auto genericParam : *genericParams) {
+              if (genericParam->getOpaqueTypeRepr() == repr)
+                return diagnoseDisallowedExistential(
+                                                     genericParam->getDeclaredInterfaceType());
+            }
+          }
+        }
       }
+    }
+
+    return resolveIdentifierType(cast<IdentTypeRepr>(repr), options);
   }
 
   case TypeReprKind::Function: {

test/type/opaque_parameterized_existential.swift

@@ -1,4 +1,5 @@
 // RUN: %target-swift-frontend -disable-availability-checking -typecheck -verify %s
+// RUN: %target-swift-frontend -disable-availability-checking -enable-experimental-implicit-some -typecheck -verify %s
 
 // I do not like nested some type params,
 // I do not like them Σam-i-am