Sema: Split off openFunctionType() from openType()

- Change openGeneric() to take two DeclContexts, one is the generic
  context for the signature and the second is the generic context
  containing the declaration being opened

- This allows us to clean up the logic around skipProtocolSelfRequirement;
  instead of testing both the DeclContext and its parent, we know
  exactly what DeclContext to test. Also, use the right Self type here,
  instead of always using (0, 0)

- Now that we have the right DeclContexts handy, we can move the
  getGenericTypeContextDepth() call into openGeneric(), simplifying
  callers

- Now that openType() no longer opens generic signatures, it takes fewer
  parameters

Author: slavapestov

lib/Sema/CSRanking.cpp

@@ -450,7 +450,8 @@ static bool isProtocolExtensionAsSpecializedAs(TypeChecker &tc,
   // the second protocol extension.
   ConstraintSystem cs(tc, dc1, None);
   llvm::DenseMap<CanType, TypeVariableType *> replacements;
-  cs.openGeneric(dc2, sig2, false, dc2->getGenericTypeContextDepth(),
+  cs.openGeneric(dc2, dc2, sig2,
+                 /*skipProtocolSelfConstraint=*/false,
                  ConstraintLocatorBuilder(nullptr),
                  replacements);
 
@@ -571,14 +572,35 @@ static bool isDeclAsSpecializedAs(TypeChecker &tc, DeclContext *dc,
       auto locator = cs.getConstraintLocator(nullptr);
       // FIXME: Locator when anchored on a declaration.
       // Get the type of a reference to the second declaration.
-      Type openedType2 = cs.openType(type2, locator,
-                                     decl2->getInnermostDeclContext());
+      llvm::DenseMap<CanType, TypeVariableType *> unused;
+      Type openedType2;
+      if (auto *funcType = type2->getAs<AnyFunctionType>()) {
+        openedType2 = cs.openFunctionType(
+            funcType, locator,
+            /*replacements=*/unused,
+            decl2->getInnermostDeclContext(),
+            decl2->getDeclContext(),
+            /*skipProtocolSelfConstraint=*/false);
+      } else {
+        openedType2 = cs.openType(type2, locator, unused);
+      }
 
       // Get the type of a reference to the first declaration, swapping in
       // archetypes for the dependent types.
       llvm::DenseMap<CanType, TypeVariableType *> replacements;
       auto dc1 = decl1->getInnermostDeclContext();
-      Type openedType1 = cs.openType(type1, locator, replacements, dc1);
+      Type openedType1;
+      if (auto *funcType = type1->getAs<AnyFunctionType>()) {
+        openedType1 = cs.openFunctionType(
+            funcType, locator,
+            replacements,
+            dc1,
+            decl1->getDeclContext(),
+            /*skipProtocolSelfConstraint=*/false);
+      } else {
+        openedType1 = cs.openType(type1, locator, replacements);
+      }
+
       for (const auto &replacement : replacements) {
         if (auto mapped = 
                   ArchetypeBuilder::mapTypeIntoContext(dc1,