AST: Cache protocol generic signature in GenericContext::getGenericSignature()

The generic signature of a protocol is simple enough that we can
build it directly when asked. However, be sure to cache it for
future use.

Author: slavapestov

lib/AST/Decl.cpp

@@ -745,13 +745,8 @@ GenericSignature *GenericContext::getGenericSignature() const {
 
   // The signature of a Protocol is trivial (Self: TheProtocol) so let's compute
   // it.
-  if (auto PD = dyn_cast<ProtocolDecl>(this)) {
-    const_cast<ProtocolDecl *>(PD)->createGenericParamsIfMissing();
-    auto self = PD->getSelfInterfaceType()->castTo<GenericTypeParamType>();
-    auto req =
-        Requirement(RequirementKind::Conformance, self, PD->getDeclaredType());
-    return GenericSignature::get({self}, {req});
-  }
+  if (auto PD = dyn_cast<ProtocolDecl>(this))
+    return getGenericEnvironment()->getGenericSignature();
 
   return nullptr;
 }
@@ -765,6 +760,21 @@ GenericEnvironment *GenericContext::getGenericEnvironment() const {
   if (GenericSigOrEnv.dyn_cast<GenericSignature *>())
     return getLazyGenericEnvironmentSlow();
 
+  // The signature of a Protocol is trivial (Self: TheProtocol) so let's compute
+  // it.
+  if (auto PD = dyn_cast<ProtocolDecl>(this)) {
+    const_cast<ProtocolDecl *>(PD)->createGenericParamsIfMissing();
+    auto self = PD->getSelfInterfaceType()->castTo<GenericTypeParamType>();
+    auto req =
+        Requirement(RequirementKind::Conformance, self, PD->getDeclaredType());
+    auto *genericSig = GenericSignature::get({self}, {req});
+
+    // Save it for next time.
+    const_cast<GenericContext *>(this)
+      ->setGenericEnvironment(genericSig->createGenericEnvironment());
+    return getGenericEnvironment();
+  }
+
   return nullptr;
 }
 

lib/Sema/ConstraintSystem.cpp

@@ -583,7 +583,11 @@ Type ConstraintSystem::openType(Type type, OpenedTypeMap &replacements) {
       if (auto genericParam = type->getAs<GenericTypeParamType>()) {
         auto known = replacements.find(
           cast<GenericTypeParamType>(genericParam->getCanonicalType()));
-        assert(known != replacements.end());
+        // FIXME: This should be an assert, however protocol generic signatures
+        // drop outer generic parameters.
+        // assert(known != replacements.end());
+        if (known == replacements.end())
+          return ErrorType::get(TC.Context);
         return known->second;
       }
 

lib/Sema/TypeCheckGeneric.cpp

@@ -754,8 +754,40 @@ GenericEnvironment *TypeChecker::checkGenericEnvironment(
 }
 
 void TypeChecker::validateGenericTypeSignature(GenericTypeDecl *typeDecl) {
+  if (auto *proto = dyn_cast<ProtocolDecl>(typeDecl)) {
+    // Compute the requirement signature first.
+    if (!proto->isRequirementSignatureComputed())
+      proto->computeRequirementSignature();
+
+    // The generic signature and environment is created lazily by
+    // GenericContext::getGenericSignature(), so there is nothing we
+    // need to do.
+
+    // Debugging of the generic signature builder and generic signature
+    // generation.
+    if (Context.LangOpts.DebugGenericSignatures) {
+      auto *sig = proto->getGenericSignature();
+
+      proto->printContext(llvm::errs());
+      llvm::errs() << "\n";
+      llvm::errs() << "Generic signature: ";
+      sig->print(llvm::errs());
+      llvm::errs() << "\n";
+      llvm::errs() << "Canonical generic signature: ";
+      sig->getCanonicalSignature()->print(llvm::errs());
+      llvm::errs() << "\n";
+    }
+
+    return;
+  }
+
   assert(!typeDecl->getGenericEnvironment());
 
+  // We don't go down this path for protocols; instead, the generic signature
+  // is simple enough that GenericContext::getGenericSignature() can build it
+  // directly.
+  assert(!isa<ProtocolDecl>(typeDecl));
+
   auto *gp = typeDecl->getGenericParams();
   auto *dc = typeDecl->getDeclContext();
 
@@ -767,13 +799,6 @@ void TypeChecker::validateGenericTypeSignature(GenericTypeDecl *typeDecl) {
 
   gp->setDepth(typeDecl->getGenericContextDepth());
 
-  // For a protocol, compute the requirement signature first. It will be used
-  // by clients of the protocol.
-  if (auto proto = dyn_cast<ProtocolDecl>(typeDecl)) {
-    if (!proto->isRequirementSignatureComputed())
-      proto->computeRequirementSignature();
-  }
-
   auto *env = checkGenericEnvironment(gp, dc,
                                       dc->getGenericSignatureOfContext(),
                                       /*allowConcreteGenericParams=*/false,

lib/Sema/TypeCheckType.cpp

@@ -3185,21 +3185,19 @@ Type TypeChecker::substMemberTypeWithBase(ModuleDecl *module,
 
   auto *aliasDecl = dyn_cast<TypeAliasDecl>(member);
   if (aliasDecl) {
+    if (aliasDecl->getGenericParams()) {
+      return UnboundGenericType::get(
+          aliasDecl, baseTy,
+          aliasDecl->getASTContext());
+    }
+
     // FIXME: If this is a protocol typealias and we haven't built the
     // protocol's generic environment yet, do so now, to ensure the
     // typealias's underlying type has fully resolved dependent
     // member types.
     if (auto *protoDecl = dyn_cast<ProtocolDecl>(aliasDecl->getDeclContext())) {
-      if (protoDecl->getGenericEnvironment() == nullptr) {
-        ASTContext &ctx = protoDecl->getASTContext();
-        ctx.getLazyResolver()->resolveProtocolEnvironment(protoDecl);
-      }
-    }
-
-    if (aliasDecl->getGenericParams()) {
-      return UnboundGenericType::get(
-          aliasDecl, baseTy,
-          aliasDecl->getASTContext());
+      ASTContext &ctx = protoDecl->getASTContext();
+      ctx.getLazyResolver()->resolveProtocolEnvironment(protoDecl);
     }
   }