Remember to set AbstractFunctionDecl's generic signature in a few places

I originally added this so that we would keep the signature around
even if type checking failed, and the function was given an
ErrorType.

Add a formal check to the AST verifier for this, and set the signature
in a few places where it wasn't being set.

Note that since we only serialize valid declarations, we don't have
to serialize a reference to the generic signature separately, but we
do have to remember to set it when deserializing, which wasn't being
done for destructors.

Author: slavapestov

lib/AST/ASTVerifier.cpp

@@ -2196,6 +2196,15 @@ struct ASTNodeBase {};
         abort();
       }
 
+      // If the function has a generic interface type, it should also have a
+      // generic signature.
+      if (AFD->getInterfaceType()->is<GenericFunctionType>() !=
+          (AFD->getGenericSignature() != nullptr)) {
+        Out << "Missing generic signature for generic function\n";
+        AFD->dump(Out);
+        abort();
+      }
+
       // If there is an interface type, it shouldn't have any unresolved
       // dependent member types.
       // FIXME: This is a general property of the type system.

lib/ClangImporter/ImportDecl.cpp

@@ -2943,6 +2943,7 @@ namespace {
             getProtocolMethodType(proto, fnType->castTo<AnyFunctionType>());
         result->setType(fnType);
         result->setInterfaceType(interfaceType);
+        result->setGenericSignature(proto->getGenericSignature());
       } else {
         result->setType(fnType);
       }
@@ -3740,6 +3741,7 @@ namespace {
       result->setBodyResultType(resultTy);
       result->setType(type);
       result->setInterfaceType(interfaceType);
+      result->setGenericSignature(dc->getGenericSignatureOfContext());
 
       // Optional methods in protocols.
       if (decl->getImplementationControl() == clang::ObjCMethodDecl::Optional &&
@@ -4215,6 +4217,7 @@ namespace {
 
         result->setInitializerInterfaceType(interfaceInitType);
         result->setInterfaceType(interfaceAllocType);
+        result->setGenericSignature(dc->getGenericSignatureOfContext());
       } else if (dc->isGenericContext()) {
         Type interfaceAllocType;
         Type interfaceInitType;
@@ -4225,6 +4228,7 @@ namespace {
 
         result->setInitializerInterfaceType(interfaceInitType);
         result->setInterfaceType(interfaceAllocType);
+        result->setGenericSignature(dc->getGenericSignatureOfContext());
         selfVar->overwriteType(initType->castTo<AnyFunctionType>()->getInput());
       }
 
@@ -4407,6 +4411,7 @@ namespace {
           getter->getClangNode());
       thunk->setBodyResultType(elementTy);
       thunk->setInterfaceType(interfaceType);
+      thunk->setGenericSignature(dc->getGenericSignatureOfContext());
       thunk->setAccessibility(Accessibility::Public);
 
       auto objcAttr = getter->getAttrs().getAttribute<ObjCAttr>();
@@ -4482,6 +4487,7 @@ namespace {
           setter->getClangNode());
       thunk->setBodyResultType(TupleType::getEmpty(C));
       thunk->setInterfaceType(interfaceType);
+      thunk->setGenericSignature(dc->getGenericSignatureOfContext());
       thunk->setAccessibility(Accessibility::Public);
 
       auto objcAttr = setter->getAttrs().getAttribute<ObjCAttr>();

lib/Sema/CodeSynthesis.cpp

@@ -1304,7 +1304,9 @@ void TypeChecker::completePropertyBehaviorParameter(VarDecl *VD,
   auto ParameterTy = BehaviorParameter->getInterfaceType()
     ->castTo<AnyFunctionType>()
     ->getResult();
-  
+
+  GenericSignature *genericSig = nullptr;
+
   TypeSubstitutionMap interfaceMap = sig->getSubstitutionMap(SelfInterfaceSubs);
   auto SubstInterfaceTy = ParameterTy.subst(VD->getModuleContext(),
                                             interfaceMap, SubstOptions());
@@ -1321,7 +1323,7 @@ void TypeChecker::completePropertyBehaviorParameter(VarDecl *VD,
   // Add the Self type back to the interface and context types.
   if (DC->isTypeContext()) {
     if (DC->isGenericContext()) {
-      auto genericSig = DC->getGenericSignatureOfContext();
+      genericSig = DC->getGenericSignatureOfContext();
       SubstInterfaceTy = GenericFunctionType::get(genericSig,
                                                   DC->getSelfInterfaceType(),
                                                   SubstInterfaceTy,
@@ -1398,6 +1400,8 @@ void TypeChecker::completePropertyBehaviorParameter(VarDecl *VD,
                      TypeLoc::withoutLoc(SubstBodyResultTy), DC);
 
   Parameter->setInterfaceType(SubstInterfaceTy);
+  Parameter->setGenericSignature(genericSig);
+
   // Mark the method to be final, implicit, and private.  In a class, this
   // prevents it from being dynamically dispatched.
   if (DC->getAsClassOrClassExtensionContext())

lib/Sema/DerivedConformanceEquatableHashable.cpp

@@ -248,6 +248,8 @@ deriveEquatable_enum_eq(TypeChecker &tc, Decl *parentDecl, EnumDecl *enumDecl) {
   // Compute the interface type.
   Type interfaceTy;
   if (auto genericSig = parentDC->getGenericSignatureOfContext()) {
+    eqDecl->setGenericSignature(genericSig);
+
     auto enumIfaceTy = parentDC->getDeclaredInterfaceType();
     TupleTypeElt ifaceParamElts[] = {
       enumIfaceTy, enumIfaceTy,
@@ -397,10 +399,11 @@ deriveHashable_enum_hashValue(TypeChecker &tc, Decl *parentDecl,
   // Compute the interface type of hashValue().
   Type interfaceType;
   Type selfIfaceType = getterDecl->computeInterfaceSelfType(false);
-  if (auto sig = parentDC->getGenericSignatureOfContext())
+  if (auto sig = parentDC->getGenericSignatureOfContext()) {
+    getterDecl->setGenericSignature(sig);
     interfaceType = GenericFunctionType::get(sig, selfIfaceType, methodType,
                                              AnyFunctionType::ExtInfo());
-  else
+  } else
     interfaceType = FunctionType::get(selfType, methodType);
 
   getterDecl->setInterfaceType(interfaceType);

lib/Sema/DerivedConformanceRawRepresentable.cpp

@@ -326,6 +326,8 @@ static ConstructorDecl *deriveRawRepresentable_init(TypeChecker &tc,
   Type allocIfaceType;
   Type initIfaceType;
   if (auto sig = parentDC->getGenericSignatureOfContext()) {
+    initDecl->setGenericSignature(sig);
+
     allocIfaceType = GenericFunctionType::get(sig, selfInterfaceType,
                                               interfaceType,
                                               FunctionType::ExtInfo());

lib/Sema/DerivedConformances.cpp

@@ -163,11 +163,12 @@ FuncDecl *DerivedConformance::declareDerivedPropertyGetter(TypeChecker &tc,
   Type interfaceType = FunctionType::get(TupleType::getEmpty(C),
                                          propertyInterfaceType);
   Type selfInterfaceType = getterDecl->computeInterfaceSelfType(false);
-  if (auto sig = parentDC->getGenericSignatureOfContext())
+  if (auto sig = parentDC->getGenericSignatureOfContext()) {
+    getterDecl->setGenericSignature(sig);
     interfaceType = GenericFunctionType::get(sig, selfInterfaceType,
                                              interfaceType,
                                              FunctionType::ExtInfo());
-  else
+  } else
     interfaceType = type;
   getterDecl->setInterfaceType(interfaceType);
   getterDecl->setAccessibility(typeDecl->getFormalAccess());

lib/Serialization/Deserialization.cpp

@@ -3226,7 +3226,12 @@ Decl *ModuleFile::getDecl(DeclID DID, Optional<DeclContext *> ForcedContext) {
     dtor->setSelfDecl(selfParams->get(0));
 
     dtor->setType(getType(signatureID));
-    dtor->setInterfaceType(getType(interfaceID));
+
+    auto interfaceType = getType(interfaceID);
+    if (auto genericFnType = interfaceType->getAs<GenericFunctionType>())
+      dtor->setGenericSignature(genericFnType->getGenericSignature());
+    dtor->setInterfaceType(interfaceType);
+
     if (isImplicit)
       dtor->setImplicit();