[AST] Teach GenericParamList amd OpaqueReturnType Request to use plain protocols

angela-laar · angela-laar · commit 5f3191c74ec3 · 2022-09-20T15:25:09.000-07:00
Originally protocols prefixed with 'some' keyword are considered an opaue return
type representation. In order to understand plain protocols, the GenericParamList
Request must understand how to build a generic parameter list using alternative
type representations: identifier and composition.
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -2822,7 +2822,7 @@ class GenericTypeDecl : public GenericContext, public TypeDecl {
 /// (opaque archetype 1))`.
 class OpaqueTypeDecl final :
     public GenericTypeDecl,
-    private llvm::TrailingObjects<OpaqueTypeDecl, OpaqueReturnTypeRepr *> {
+    private llvm::TrailingObjects<OpaqueTypeDecl, TypeRepr *> {
   friend TrailingObjects;
 
 public:
@@ -2866,7 +2866,7 @@ class OpaqueTypeDecl final :
   OpaqueTypeDecl(ValueDecl *NamingDecl, GenericParamList *GenericParams,
                  DeclContext *DC,
                  GenericSignature OpaqueInterfaceGenericSignature,
-                 ArrayRef<OpaqueReturnTypeRepr *> OpaqueReturnTypeReprs);
+                 ArrayRef<TypeRepr *> OpaqueReturnTypeReprs);
 
   unsigned getNumOpaqueReturnTypeReprs() const {
     return NamingDeclAndHasOpaqueReturnTypeRepr.getInt()
@@ -2883,7 +2883,7 @@ class OpaqueTypeDecl final :
       ValueDecl *NamingDecl, GenericParamList *GenericParams,
       DeclContext *DC,
       GenericSignature OpaqueInterfaceGenericSignature,
-      ArrayRef<OpaqueReturnTypeRepr *> OpaqueReturnTypeReprs);
+      ArrayRef<TypeRepr *> OpaqueReturnTypeReprs);
 
   ValueDecl *getNamingDecl() const {
     return NamingDeclAndHasOpaqueReturnTypeRepr.getPointer();
@@ -2928,9 +2928,9 @@ class OpaqueTypeDecl final :
 
   /// Retrieve the buffer containing the opaque return type
   /// representations that correspond to the opaque generic parameters.
-  ArrayRef<OpaqueReturnTypeRepr *> getOpaqueReturnTypeReprs() const {
+  ArrayRef<TypeRepr *> getOpaqueReturnTypeReprs() const {
     return {
-      getTrailingObjects<OpaqueReturnTypeRepr *>(),
+      getTrailingObjects<TypeRepr *>(),
       getNumOpaqueReturnTypeReprs()
     };
   }
@@ -3163,7 +3163,7 @@ class AbstractTypeParamDecl : public TypeDecl {
 /// \endcode
 class GenericTypeParamDecl final :
     public AbstractTypeParamDecl,
-    private llvm::TrailingObjects<GenericTypeParamDecl, OpaqueReturnTypeRepr *>{
+    private llvm::TrailingObjects<GenericTypeParamDecl, TypeRepr *>{
   friend TrailingObjects;
 
   size_t numTrailingObjects(OverloadToken<OpaqueReturnTypeRepr *>) const {
@@ -3180,7 +3180,7 @@ class GenericTypeParamDecl final :
   /// \param nameLoc The location of the name.
   GenericTypeParamDecl(DeclContext *dc, Identifier name, SourceLoc nameLoc,
                        bool isTypeSequence, unsigned depth, unsigned index,
-                       bool isOpaqueType, OpaqueReturnTypeRepr *opaqueTypeRepr);
+                       bool isOpaqueType, TypeRepr *typeRepr);
 
 public:
   /// Construct a new generic type parameter.
@@ -3201,7 +3201,7 @@ class GenericTypeParamDecl final :
   static GenericTypeParamDecl *
   create(DeclContext *dc, Identifier name, SourceLoc nameLoc,
          bool isTypeSequence, unsigned depth, unsigned index,
-         bool isOpaqueType, OpaqueReturnTypeRepr *opaqueTypeRepr);
+         bool isOpaqueType, TypeRepr *typeRepr);
 
   /// The depth of this generic type parameter, i.e., the number of outer
   /// levels of generic parameter lists that enclose this type parameter.
@@ -3249,11 +3249,11 @@ class GenericTypeParamDecl final :
   ///     extension, meaning that it was specified explicitly
   ///   - the enclosing declaration was deserialized, in which case it lost
   ///     the source location information and has no type representation.
-  OpaqueReturnTypeRepr *getOpaqueTypeRepr() const {
+  TypeRepr *getOpaqueTypeRepr() const {
     if (!isOpaqueType())
       return nullptr;
 
-    return *getTrailingObjects<OpaqueReturnTypeRepr *>();
+    return *getTrailingObjects<TypeRepr *>();
   }
 
   /// The index of this generic type parameter within its generic parameter
diff --git a/include/swift/AST/TypeRepr.h b/include/swift/AST/TypeRepr.h
@@ -48,7 +48,9 @@ enum : unsigned { NumTypeReprKindBits =
   countBitsUsed(static_cast<unsigned>(TypeReprKind::Last_TypeRepr)) };
 
 class OpaqueReturnTypeRepr;
-using CollectedOpaqueReprs = SmallVector<OpaqueReturnTypeRepr *, 2>;
+//using CollectedOpaqueReprs = SmallVector<OpaqueReturnTypeRepr *, 2>;
+using CollectedOpaqueReprs = SmallVector<TypeRepr *, 2>; //change to TypeRepr
+
 
 /// Representation of a type as written in source.
 class alignas(1 << TypeReprAlignInBits) TypeRepr
@@ -169,6 +171,10 @@ class alignas(1 << TypeReprAlignInBits) TypeRepr
   /// `OpaqueReturnTypeRepr`s.
   CollectedOpaqueReprs collectOpaqueReturnTypeReprs();
 
+  /// Walk the type representation recursively, collecting any
+  /// `CompositionTypeRepr`s and `IdentTypeRepr`s.
+  CollectedOpaqueReprs collectTypeReprs();
+
   /// Retrieve the type repr without any parentheses around it.
   ///
   /// The use of this function must be restricted to contexts where
@@ -844,7 +850,7 @@ class TupleTypeRepr final : public TypeRepr,
 ///   Foo & Bar
 /// \endcode
 class CompositionTypeRepr final : public TypeRepr,
-    private llvm::TrailingObjects<CompositionTypeRepr, TypeRepr*> {
+  private llvm::TrailingObjects<CompositionTypeRepr, TypeRepr*> {
   friend TrailingObjects;
   SourceLoc FirstTypeLoc;
   SourceRange CompositionRange;
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -4592,17 +4592,17 @@ AbstractTypeParamDecl::getConformingProtocols() const {
 GenericTypeParamDecl::GenericTypeParamDecl(
     DeclContext *dc, Identifier name, SourceLoc nameLoc,
     bool isTypeSequence, unsigned depth, unsigned index,
-    bool isOpaqueType, OpaqueReturnTypeRepr *opaqueTypeRepr
+    bool isOpaqueType, TypeRepr *typeRepr
   ) : AbstractTypeParamDecl(DeclKind::GenericTypeParam, dc, name, nameLoc) {
   Bits.GenericTypeParamDecl.Depth = depth;
   assert(Bits.GenericTypeParamDecl.Depth == depth && "Truncation");
   Bits.GenericTypeParamDecl.Index = index;
   assert(Bits.GenericTypeParamDecl.Index == index && "Truncation");
   Bits.GenericTypeParamDecl.TypeSequence = isTypeSequence;
   Bits.GenericTypeParamDecl.IsOpaqueType = isOpaqueType;
-  assert(isOpaqueType || !opaqueTypeRepr);
+  assert(isOpaqueType || !typeRepr);
   if (isOpaqueType)
-    *getTrailingObjects<OpaqueReturnTypeRepr *>() = opaqueTypeRepr;
+    *getTrailingObjects<TypeRepr *>() = typeRepr;
 
   auto &ctx = dc->getASTContext();
   RecursiveTypeProperties props = RecursiveTypeProperties::HasTypeParameter;
@@ -4616,14 +4616,14 @@ GenericTypeParamDecl *
 GenericTypeParamDecl::create(
     DeclContext *dc, Identifier name, SourceLoc nameLoc,
     bool isTypeSequence, unsigned depth, unsigned index,
-    bool isOpaqueType, OpaqueReturnTypeRepr *opaqueTypeRepr) {
+    bool isOpaqueType, TypeRepr *typeRepr) {
   ASTContext &ctx = dc->getASTContext();
   auto mem = ctx.Allocate(
-      totalSizeToAlloc<OpaqueReturnTypeRepr *>(isOpaqueType ? 1 : 0),
+      totalSizeToAlloc<TypeRepr *>(isOpaqueType ? 1 : 0),
       alignof(GenericTypeParamDecl));
   return new (mem) GenericTypeParamDecl(
       dc, name, nameLoc, isTypeSequence, depth, index, isOpaqueType,
-      opaqueTypeRepr);
+      typeRepr);
 }
 
 
@@ -8252,7 +8252,7 @@ void AbstractFunctionDecl::setParameters(ParameterList *BodyParams) {
 OpaqueTypeDecl::OpaqueTypeDecl(ValueDecl *NamingDecl,
                                GenericParamList *GenericParams, DeclContext *DC,
                                GenericSignature OpaqueInterfaceGenericSignature,
-                               ArrayRef<OpaqueReturnTypeRepr *>
+                               ArrayRef<TypeRepr *>
                                    OpaqueReturnTypeReprs)
     : GenericTypeDecl(DeclKind::OpaqueType, DC, Identifier(), SourceLoc(), {},
                       GenericParams),
@@ -8269,16 +8269,16 @@ OpaqueTypeDecl::OpaqueTypeDecl(ValueDecl *NamingDecl,
             OpaqueInterfaceGenericSignature.getInnermostGenericParams().size());
   std::uninitialized_copy(
       OpaqueReturnTypeReprs.begin(), OpaqueReturnTypeReprs.end(),
-      getTrailingObjects<OpaqueReturnTypeRepr *>());
+      getTrailingObjects<TypeRepr *>());
 }
 
 OpaqueTypeDecl *OpaqueTypeDecl::get(
       ValueDecl *NamingDecl, GenericParamList *GenericParams,
       DeclContext *DC,
       GenericSignature OpaqueInterfaceGenericSignature,
-      ArrayRef<OpaqueReturnTypeRepr *> OpaqueReturnTypeReprs) {
+      ArrayRef<TypeRepr *> OpaqueReturnTypeReprs) {
   ASTContext &ctx = DC->getASTContext();
-  auto size = totalSizeToAlloc<OpaqueReturnTypeRepr *>(
+  auto size = totalSizeToAlloc<TypeRepr *>(
       OpaqueReturnTypeReprs.size());
   auto mem = ctx.Allocate(size, alignof(OpaqueTypeDecl));
   return new (mem) OpaqueTypeDecl(
diff --git a/lib/AST/NameLookup.cpp b/lib/AST/NameLookup.cpp
@@ -2764,6 +2764,19 @@ static bool declsAreAssociatedTypes(ArrayRef<TypeDecl *> decls) {
   return true;
 }
 
+/// Whether there are only protocol decl types 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;
+}
+
 static GenericParamList *
 createExtensionGenericParams(ASTContext &ctx,
                              ExtensionDecl *ext,
@@ -2789,6 +2802,7 @@ static SmallVector<GenericTypeParamDecl *, 2>
 createOpaqueParameterGenericParams(
     GenericContext *genericContext, GenericParamList *parsedGenericParams) {
   ASTContext &ctx = genericContext->getASTContext();
+    
   auto value = dyn_cast_or_null<ValueDecl>(genericContext->getAsDecl());
   if (!value)
     return { };
@@ -2811,21 +2825,33 @@ createOpaqueParameterGenericParams(
     if (!typeRepr)
       continue;
 
-    auto opaqueTypeReprs = typeRepr->collectOpaqueReturnTypeReprs();
-    for (auto opaqueRepr : opaqueTypeReprs) {
+    // Plain protocols should imply 'some' with experimetal feature
+    CollectedOpaqueReprs typeReprs;
+    if (ctx.LangOpts.hasFeature(Feature::ImplicitSome)) {
+        typeReprs = typeRepr->collectTypeReprs();
+    } else {  typeReprs = typeRepr->collectOpaqueReturnTypeReprs(); }
+
+      for (auto repr : typeReprs) {
+        if (isa<IdentTypeRepr>(repr)){
+              DirectlyReferencedTypeDecls d = directReferencesForTypeRepr(ctx.evaluator, ctx, repr, dc, true);
+              if(!declsAreProtocols(d))
+                  continue;
+        }
       // Allocate a new generic parameter to represent this opaque type.
-      auto gp = GenericTypeParamDecl::create(
+        auto gp = GenericTypeParamDecl::create(
           dc, Identifier(), SourceLoc(), /*isTypeSequence=*/false,
           GenericTypeParamDecl::InvalidDepth, index++, /*isOpaqueType=*/true,
-          opaqueRepr);
-      gp->setImplicit();
+          repr);
+        gp->setImplicit();
 
       // Use the underlying constraint as the constraint on the generic parameter.
-      InheritedEntry inherited[1] = {
-        { TypeLoc(opaqueRepr->getConstraint()) }
-      };
-      gp->setInherited(ctx.AllocateCopy(inherited));
-
+      //  The underlying constraint is only present for OpaqueReturnTypeReprs
+        if( auto opaque = dyn_cast<OpaqueReturnTypeRepr>(repr)){
+              InheritedEntry inherited[1] = {
+                  { TypeLoc(opaque->getConstraint()) }
+              };
+              gp->setInherited(ctx.AllocateCopy(inherited));
+        }
       implicitGenericParams.push_back(gp);
     }
   }
diff --git a/lib/AST/TypeRepr.cpp b/lib/AST/TypeRepr.cpp
@@ -137,6 +137,30 @@ CollectedOpaqueReprs TypeRepr::collectOpaqueReturnTypeReprs() {
   return reprs;
 }
 
+CollectedOpaqueReprs TypeRepr::collectTypeReprs() {
+  class Walker : public ASTWalker {
+    CollectedOpaqueReprs &Reprs;
+
+  public:
+    explicit Walker(CollectedOpaqueReprs &reprs) : Reprs(reprs) {}
+
+    bool walkToTypeReprPre(TypeRepr *repr) override {
+      if (auto opaqueRepr = dyn_cast<OpaqueReturnTypeRepr>(repr)){
+            Reprs.push_back(opaqueRepr);
+      } else if (auto compositionRepr = dyn_cast<CompositionTypeRepr>(repr)){
+          Reprs.push_back(compositionRepr);
+      } else if (auto identRepr = dyn_cast<IdentTypeRepr>(repr)){
+              Reprs.push_back(identRepr);
+      }
+    return true;
+    }
+  };
+
+  CollectedOpaqueReprs reprs;
+  walk(Walker(reprs));
+  return reprs;
+}
+
 SourceLoc TypeRepr::findUncheckedAttrLoc() const {
   auto typeRepr = this;
   while (auto attrTypeRepr = dyn_cast<AttributedTypeRepr>(typeRepr)) {
diff --git a/lib/Frontend/CompilerInvocation.cpp b/lib/Frontend/CompilerInvocation.cpp
@@ -686,7 +686,7 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     Opts.Features.insert(Feature::AdditiveArithmeticDerivedConformances);
   if (Args.hasArg(OPT_enable_experimental_opaque_type_erasure))
     Opts.Features.insert(Feature::OpaqueTypeErasure);
-  if (Args.hasArg(OPT_enable_experimental_variadic_generics)){
+  if (Args.hasArg(OPT_enable_experimental_implicit_some)){
       Opts.Features.insert(Feature::ImplicitSome);
       Opts.Features.insert(Feature::ExistentialAny);
   }
diff --git a/lib/Sema/TypeCheckGeneric.cpp b/lib/Sema/TypeCheckGeneric.cpp

Original file line number	Diff line number	Diff line change
`@@ -686,7 +686,7 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,`
`686`	`686`	`Opts.Features.insert(Feature::AdditiveArithmeticDerivedConformances);`
`687`	`687`	`if (Args.hasArg(OPT_enable_experimental_opaque_type_erasure))`
`688`	`688`	`Opts.Features.insert(Feature::OpaqueTypeErasure);`
`689`		`- if (Args.hasArg(OPT_enable_experimental_variadic_generics)){`
	`689`	`+ if (Args.hasArg(OPT_enable_experimental_implicit_some)){`
`690`	`690`	`Opts.Features.insert(Feature::ImplicitSome);`
`691`	`691`	`Opts.Features.insert(Feature::ExistentialAny);`
`692`	`692`	`}`