[AST] Verify identifier type representations are protocols

Now that GenericParamListRequest and OpaqueResultTypeRequest know
to check for IdentTypeReprs when scanning for opaque parameters,
the requests need to know it should only create Generic Paramters
and Opaque Type Decls for IdentTypeReprs that are protocols.
We should add a function to the swift namespace to check.

Author: angela-laar

include/swift/AST/ASTWalker.h

@@ -21,14 +21,17 @@
 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 {
@@ -472,6 +475,8 @@ 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

@@ -27,21 +27,38 @@
 #include "swift/Basic/SourceLoc.h"
 #include "swift/Basic/SourceManager.h"
 #include "llvm/ADT/SmallVector.h"
+#include "swift/AST/TypeRepr.h"
 
 namespace swift {
 class ASTContext;
+class ASTWalker;
 class DeclName;
 class Type;
 class TypeDecl;
 class ValueDecl;
 struct SelfBounds;
 class NominalTypeDecl;
+class Evaluator;
 
 namespace ast_scope {
 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);
+
+
 /// LookupResultEntry - One result of unqualified lookup.
 struct LookupResultEntry {
 private:
@@ -520,6 +537,7 @@ 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.
@@ -638,7 +656,7 @@ class FindLocalVal : public StmtVisitor<FindLocalVal> {
 
 };
 
-  
+
 /// The bridge between the legacy UnqualifiedLookupFactory and the new ASTScope
 /// lookup system
 class AbstractASTScopeDeclConsumer {

include/swift/AST/TypeRepr.h

@@ -167,14 +167,6 @@ class alignas(1 << TypeReprAlignInBits) TypeRepr
   /// opaque return type reprs.
   bool hasOpaque();
 
-  /// Walk the type representation recursively, collecting any
-  /// `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

lib/AST/NameLookup.cpp

@@ -17,6 +17,7 @@
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTVisitor.h"
+#include "swift/AST/ASTWalker.h"
 #include "swift/AST/ClangModuleLoader.h"
 #include "swift/AST/DebuggerClient.h"
 #include "swift/AST/ExistentialLayout.h"
@@ -2796,11 +2797,53 @@ 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) {
+  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;
+  r->walk(Walker(reprs));
+  return reprs;
+}
+
 /// If there are opaque parameters in the given declaration, create the
 /// generic parameters associated with them.
 static SmallVector<GenericTypeParamDecl *, 2>
-createOpaqueParameterGenericParams(
-    GenericContext *genericContext, GenericParamList *parsedGenericParams) {
+createOpaqueParameterGenericParams(Evaluator &evaluator,GenericContext *genericContext, GenericParamList *parsedGenericParams) {
   ASTContext &ctx = genericContext->getASTContext();
 
   auto value = dyn_cast_or_null<ValueDecl>(genericContext->getAsDecl());
@@ -2828,14 +2871,14 @@ createOpaqueParameterGenericParams(
     // Plain protocols should imply 'some' with experimetal feature
     CollectedOpaqueReprs typeReprs;
     if (ctx.LangOpts.hasFeature(Feature::ImplicitSome)) {
-        typeReprs = typeRepr->collectTypeReprs();
-    } else {  typeReprs = typeRepr->collectOpaqueReturnTypeReprs(); }
+        typeReprs = collectTypeReprs(typeRepr);
+    } else {  typeReprs = collectOpaqueReturnTypeReprs(typeRepr); }
 
       for (auto repr : typeReprs) {
+   
         if (isa<IdentTypeRepr>(repr)){
-              DirectlyReferencedTypeDecls d = directReferencesForTypeRepr(ctx.evaluator, ctx, repr, dc, true);
-              if(!declsAreProtocols(d))
-                  continue;
+            if(!isProtocol(evaluator,repr, ctx, dc))
+              continue;
         }
       // Allocate a new generic parameter to represent this opaque type.
         auto gp = GenericTypeParamDecl::create(
@@ -2859,6 +2902,14 @@ createOpaqueParameterGenericParams(
   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)) {
@@ -2929,7 +2980,7 @@ GenericParamListRequest::evaluate(Evaluator &evaluator, GenericContext *value) c
   // Create implicit generic parameters due to opaque parameters, if we need
   // them.
   auto implicitGenericParams =
-      createOpaqueParameterGenericParams(value, parsedGenericParams);
+      createOpaqueParameterGenericParams(evaluator, value, parsedGenericParams);
   if (implicitGenericParams.empty())
     return parsedGenericParams;
 

lib/Sema/TypeCheckGeneric.cpp

@@ -16,6 +16,7 @@
 #include "TypeCheckProtocol.h"
 #include "TypeCheckType.h"
 #include "TypeChecker.h"
+#include "swift/AST/NameLookup.h"
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/DiagnosticsSema.h"
 #include "swift/AST/ExistentialLayout.h"
@@ -29,6 +30,7 @@
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace swift;
+using namespace swift::namelookup;
 
 //
 // Generic functions
@@ -135,15 +137,20 @@ OpaqueResultTypeRequest::evaluate(Evaluator &evaluator,
     }
   } else {
       if (ctx.LangOpts.hasFeature(Feature::ImplicitSome)) {
-          opaqueReprs = repr->collectTypeReprs();
+          opaqueReprs = collectTypeReprs(repr);
       } else {
-          opaqueReprs = repr->collectOpaqueReturnTypeReprs();
+          opaqueReprs = collectOpaqueReturnTypeReprs(repr);
       }
     SmallVector<GenericTypeParamType *, 2> genericParamTypes;
     SmallVector<Requirement, 2> requirements;
       for (unsigned i = 0; i < opaqueReprs.size(); ++i) {
           auto *currentRepr = opaqueReprs[i];
 
+          if (isa<IdentTypeRepr>(currentRepr)){
+              if(!isProtocol(evaluator, currentRepr, ctx, dc))
+                continue;
+          }
+
           if( auto opaqueReturnRepr = dyn_cast<OpaqueReturnTypeRepr>(currentRepr) ) {
               // Usually, we resolve the opaque constraint and bail if it isn't a class
               // or existential type (see below). However, in this case we know we will