[AST] Ignore existential types when building opaque parameter list

Author: angela-laar

include/swift/AST/ASTWalker.h

@@ -21,17 +21,14 @@
 namespace swift {
 
 class ArgumentList;
-class ASTContext;
 class Decl;
 class Expr;
 class ClosureExpr;
 class ModuleDecl;
-class DeclContext;
 class Stmt;
 class Pattern;
 class TypeRepr;
 class ParameterList;
-class Evaluator;
 enum class AccessKind: unsigned char;
 
 enum class SemaReferenceKind : uint8_t {
@@ -475,8 +472,6 @@ class ASTWalker {
     return Action::Continue();
   }
 
-  virtual bool walkToTypeReprPre(Evaluator &evaluator, TypeRepr *T, ASTContext &ctx, DeclContext *dc) { return true; }
-
   /// This method is called after visiting the children of a TypeRepr.
   ///
   /// \param T The type that was walked.

include/swift/AST/NameLookup.h

@@ -45,19 +45,9 @@ class ASTSourceFileScope;
 class ASTScopeImpl;
 } // namespace ast_scope
 
-using CollectedOpaqueReprs = SmallVector<TypeRepr *, 2>;
-
-/// Walk the type representation recursively, collecting any
-/// `OpaqueReturnTypeRepr`s.
-CollectedOpaqueReprs collectOpaqueReturnTypeReprs(TypeRepr *);
-
 /// Walk the type representation recursively, collecting any
-/// `CompositionTypeRepr`s and `IdentTypeRepr`s.
-CollectedOpaqueReprs collectTypeReprs(TypeRepr *);
-
-/// Given a Type Representation, decide if it is a protocol
-bool isProtocol(Evaluator &evaluator, TypeRepr *r, ASTContext &ctx, DeclContext *dc);
-
+/// `OpaqueReturnTypeRepr`s, `CompositionTypeRepr`s  or `IdentTypeRepr`s.
+CollectedOpaqueReprs collectOpaqueReturnTypeReprs(TypeRepr *, ASTContext &ctx, DeclContext *dc);
 
 /// LookupResultEntry - One result of unqualified lookup.
 struct LookupResultEntry {
@@ -537,7 +527,6 @@ void filterForDiscriminator(SmallVectorImpl<Result> &results,
 
 } // end namespace namelookup
 
-
 /// Describes an inherited nominal entry.
 struct InheritedNominalEntry : Located<NominalTypeDecl *> {
   /// The location of the "unchecked" attribute, if present.
@@ -656,7 +645,6 @@ class FindLocalVal : public StmtVisitor<FindLocalVal> {
 
 };
 
-
 /// The bridge between the legacy UnqualifiedLookupFactory and the new ASTScope
 /// lookup system
 class AbstractASTScopeDeclConsumer {

include/swift/AST/TypeRepr.h

@@ -33,6 +33,7 @@
 #include "llvm/Support/TrailingObjects.h"
 
 namespace swift {
+  class ASTContext;
   class ASTWalker;
   class DeclContext;
   class IdentTypeRepr;
@@ -48,9 +49,7 @@ enum : unsigned { NumTypeReprKindBits =
   countBitsUsed(static_cast<unsigned>(TypeReprKind::Last_TypeRepr)) };
 
 class OpaqueReturnTypeRepr;
-//using CollectedOpaqueReprs = SmallVector<OpaqueReturnTypeRepr *, 2>;
-using CollectedOpaqueReprs = SmallVector<TypeRepr *, 2>; //change to TypeRepr
-
+using CollectedOpaqueReprs = SmallVector<TypeRepr *, 2>;
 
 /// Representation of a type as written in source.
 class alignas(1 << TypeReprAlignInBits) TypeRepr
@@ -120,6 +119,9 @@ class alignas(1 << TypeReprAlignInBits) TypeRepr
     return static_cast<TypeReprKind>(Bits.TypeRepr.Kind);
   }
 
+  /// Is this type representation a protocol?
+  bool isProtocol(DeclContext *dc);
+
   /// Is this type representation known to be invalid?
   bool isInvalid() const { return Bits.TypeRepr.Invalid; }
 
@@ -842,7 +844,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;
@@ -864,6 +866,12 @@ class CompositionTypeRepr final : public TypeRepr,
   SourceLoc getSourceLoc() const { return FirstTypeLoc; }
   SourceRange getCompositionRange() const { return CompositionRange; }
 
+  /// 'Any' is understood as CompositionTypeRepr by the compiler but its type array will be empty
+  ///  becasue it is a  nonspecific type
+  bool isTypeReprAny() {
+        return getTypes().size() == 0 ?  true : false;
+  }
+  
   static CompositionTypeRepr *create(const ASTContext &C,
                                      ArrayRef<TypeRepr*> Protocols,
                                      SourceLoc FirstTypeLoc,

lib/AST/NameLookup.cpp

@@ -2765,7 +2765,7 @@ static bool declsAreAssociatedTypes(ArrayRef<TypeDecl *> decls) {
   return true;
 }
 
-/// Whether there are only protocol decl types in the set of declarations.
+/// Verify there are only protocols in the set of declarations.
 static bool declsAreProtocols(ArrayRef<TypeDecl *> decls) {
   if (decls.empty())
     return false;
@@ -2774,10 +2774,15 @@ static bool declsAreProtocols(ArrayRef<TypeDecl *> decls) {
     if (!isa<ProtocolDecl>(decl))
         return false;
   }
-
   return true;
 }
 
+bool TypeRepr::isProtocol(DeclContext *dc){
+  auto &ctx = dc->getASTContext();
+  DirectlyReferencedTypeDecls d = directReferencesForTypeRepr(ctx.evaluator, ctx, this, dc);
+  return declsAreProtocols(d);
+}
+
 static GenericParamList *
 createExtensionGenericParams(ASTContext &ctx,
                              ExtensionDecl *ext,
@@ -2797,54 +2802,48 @@ createExtensionGenericParams(ASTContext &ctx,
   return toParams;
 }
 
-CollectedOpaqueReprs swift::collectOpaqueReturnTypeReprs(TypeRepr *r) {
-  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);
-      return true;
-    }
-  };
-
-  CollectedOpaqueReprs reprs;
-  r->walk(Walker(reprs));
-  return reprs;
-}
-
-CollectedOpaqueReprs swift::collectTypeReprs(TypeRepr *r) {
+CollectedOpaqueReprs swift::collectOpaqueReturnTypeReprs(TypeRepr *r, ASTContext &ctx, DeclContext *d) {
   class Walker : public ASTWalker {
     CollectedOpaqueReprs &Reprs;
+    ASTContext &Ctx;
+    DeclContext *dc;
 
   public:
-    explicit Walker(CollectedOpaqueReprs &reprs) : Reprs(reprs) {}
+    explicit Walker(CollectedOpaqueReprs &reprs, ASTContext &ctx, DeclContext *d) : Reprs(reprs), Ctx(ctx), dc(d) {}
 
     bool walkToTypeReprPre(TypeRepr *repr) override {
+      if (auto existential = dyn_cast<ExistentialTypeRepr>(repr)) {
+        return false;
+      }
+      
       if (auto opaqueRepr = dyn_cast<OpaqueReturnTypeRepr>(repr)){
-          Reprs.push_back(opaqueRepr);
+        Reprs.push_back(opaqueRepr);
+        if (Ctx.LangOpts.hasFeature(Feature::ImplicitSome))
           return false;
-      } else if (auto compositionRepr = dyn_cast<CompositionTypeRepr>(repr)){
-          Reprs.push_back(compositionRepr);
-      } else if (auto identRepr = dyn_cast<IdentTypeRepr>(repr)){
-          Reprs.push_back(identRepr);
+      }
+      
+      if (Ctx.LangOpts.hasFeature(Feature::ImplicitSome)){
+        if (auto compositionRepr = dyn_cast<CompositionTypeRepr>(repr)){
+          if (!compositionRepr->isTypeReprAny())
+            Reprs.push_back(compositionRepr);
+        } else if (auto identRepr = dyn_cast<IdentTypeRepr>(repr)) {
+          if (identRepr->isProtocol(dc))
+            Reprs.push_back(identRepr);
+        }
       }
     return true;
     }
   };
 
   CollectedOpaqueReprs reprs;
-  r->walk(Walker(reprs));
+  r->walk(Walker(reprs, ctx, d));
   return reprs;
 }
 
 /// If there are opaque parameters in the given declaration, create the
 /// generic parameters associated with them.
 static SmallVector<GenericTypeParamDecl *, 2>
-createOpaqueParameterGenericParams(Evaluator &evaluator,GenericContext *genericContext, GenericParamList *parsedGenericParams) {
+createOpaqueParameterGenericParams(GenericContext *genericContext, GenericParamList *parsedGenericParams) {
   ASTContext &ctx = genericContext->getASTContext();
 
   auto value = dyn_cast_or_null<ValueDecl>(genericContext->getAsDecl());
@@ -2871,51 +2870,37 @@ createOpaqueParameterGenericParams(Evaluator &evaluator,GenericContext *genericC
 
     // Plain protocols should imply 'some' with experimetal feature
     CollectedOpaqueReprs typeReprs;
-    if (ctx.LangOpts.hasFeature(Feature::ImplicitSome)) {
-        typeReprs = collectTypeReprs(typeRepr);
-    } else {  typeReprs = collectOpaqueReturnTypeReprs(typeRepr); }
+    typeReprs = collectOpaqueReturnTypeReprs(typeRepr, ctx, dc);
 
-      for (auto repr : typeReprs) {
+    for (auto repr : typeReprs) {
 
-        if (isa<IdentTypeRepr>(repr)){
-            if(!isProtocol(evaluator,repr, ctx, dc))
-              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,
           repr);
-        gp->setImplicit();
+      gp->setImplicit();
 
       // Use the underlying constraint as the constraint on the generic parameter.
       //  The underlying constraint is only present for OpaqueReturnTypeReprs
-        if( auto opaque = dyn_cast<OpaqueReturnTypeRepr>(repr)){
+      if (auto opaque = dyn_cast<OpaqueReturnTypeRepr>(repr)) {
               InheritedEntry inherited[1] = {
                   { TypeLoc(opaque->getConstraint()) }
               };
               gp->setInherited(ctx.AllocateCopy(inherited));
-        } else {
+      } else {
             InheritedEntry inherited[1] = {
                 { TypeLoc(repr) }
             };
             gp->setInherited(ctx.AllocateCopy(inherited));
-        }
+      }
       implicitGenericParams.push_back(gp);
     }
   }
 
   return implicitGenericParams;
 }
 
-
-bool swift::isProtocol( Evaluator &evaluator, TypeRepr *r, ASTContext &ctx, DeclContext *dc) {
-    DirectlyReferencedTypeDecls d = directReferencesForTypeRepr(evaluator, ctx, r, dc);
-    if(declsAreProtocols(d)){
-        return true;
-    } else { return false; }
-}
-
 GenericParamList *
 GenericParamListRequest::evaluate(Evaluator &evaluator, GenericContext *value) const {
   if (auto *tupleDecl = dyn_cast<BuiltinTupleDecl>(value)) {
@@ -2986,7 +2971,7 @@ GenericParamListRequest::evaluate(Evaluator &evaluator, GenericContext *value) c
   // Create implicit generic parameters due to opaque parameters, if we need
   // them.
   auto implicitGenericParams =
-      createOpaqueParameterGenericParams(evaluator, value, parsedGenericParams);
+      createOpaqueParameterGenericParams(value, parsedGenericParams);
   if (implicitGenericParams.empty())
     return parsedGenericParams;
 

lib/AST/TypeRepr.cpp

@@ -29,6 +29,7 @@
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace swift;
+//using namespace swift::namelookup;
 
 #define TYPEREPR(Id, _) \
   static_assert(IsTriviallyDestructible<Id##TypeRepr>::value, \