Sema: Introduce a simpler form of checkGenericArguments()

Author: slavapestov

lib/Sema/CSStep.cpp

@@ -538,8 +538,8 @@ StepResult DisjunctionStep::resume(bool prevFailed) {
 }
 
 bool IsDeclRefinementOfRequest::evaluate(Evaluator &evaluator,
-                                          ValueDecl *declA,
-                                          ValueDecl *declB) const {
+                                         ValueDecl *declA,
+                                         ValueDecl *declB) const {
   auto *typeA = declA->getInterfaceType()->getAs<GenericFunctionType>();
   auto *typeB = declB->getInterfaceType()->getAs<GenericFunctionType>();
 
@@ -578,10 +578,7 @@ bool IsDeclRefinementOfRequest::evaluate(Evaluator &evaluator,
     return false;
 
   auto result = TypeChecker::checkGenericArguments(
-      declA->getDeclContext(), SourceLoc(), SourceLoc(), typeB,
-      genericSignatureB->getGenericParams(),
-      genericSignatureB->getRequirements(),
-      QueryTypeSubstitutionMap{ substMap });
+      genericSignatureB, QueryTypeSubstitutionMap{ substMap });
 
   if (result != RequirementCheckResult::Success)
     return false;

lib/Sema/CodeSynthesis.cpp

@@ -745,9 +745,7 @@ createDesignatedInitOverride(ClassDecl *classDecl,
     // satisfied by the derived class. In this case, we don't want to inherit
     // this initializer; there's no way to call it on the derived class.
     auto checkResult = TypeChecker::checkGenericArguments(
-        superclassCtor, SourceLoc(), SourceLoc(), Type(),
-        superclassCtorSig->getGenericParams(),
-        superclassCtorSig->getRequirements(),
+        superclassCtorSig,
         [&](Type type) -> Type {
           auto substType = type.subst(overrideInfo.OverrideSubMap);
           return GenericEnvironment::mapTypeIntoContext(

lib/Sema/IDETypeCheckingRequests.cpp

@@ -116,36 +116,6 @@ class ContainsSpecializableArchetype : public TypeWalker {
   }
 };
 
-static bool areGenericRequirementsSatisfied(GenericSignature sig,
-                                            SubstitutionMap substMap,
-                                            bool isExtension) {
-  SmallVector<Requirement, 4> worklist;
-
-  for (auto req : sig->getRequirements()) {
-    if (auto resolved = req.subst(
-          QuerySubstitutionMap{substMap},
-          LookUpConformanceInSignature(sig.getPointer()))) {
-      worklist.push_back(*resolved);
-    } else if (isExtension) {
-      return false;
-    }
-    // Unresolved requirements are requirements of the function itself. This
-    // does not prevent it from being applied. E.g. func foo<T: Sequence>(x: T).
-  }
-
-  while (!worklist.empty()) {
-    auto req = worklist.pop_back_val();
-    ArrayRef<Requirement> conditionalRequirements;
-    if (req.isSatisfied(conditionalRequirements) != Requirement::Satisfied)
-      return false;
-
-    worklist.append(conditionalRequirements.begin(),
-                    conditionalRequirements.end());
-  }
-
-  return true;
-}
-
 static bool isExtensionAppliedInternal(const DeclContext *DC, Type BaseTy,
                                        const ExtensionDecl *ED) {
   // We can't do anything if the base type has unbound generic parameters.
@@ -163,8 +133,9 @@ static bool isExtensionAppliedInternal(const DeclContext *DC, Type BaseTy,
   GenericSignature genericSig = ED->getGenericSignature();
   SubstitutionMap substMap = BaseTy->getContextSubstitutionMap(
       DC->getParentModule(), ED->getExtendedNominal());
-  return areGenericRequirementsSatisfied(genericSig, substMap,
-                                         /*isExtension=*/true);
+  return TypeChecker::checkGenericArguments(
+      genericSig, QuerySubstitutionMap{substMap})
+      == RequirementCheckResult::Success;
 }
 
 static bool isMemberDeclAppliedInternal(const DeclContext *DC, Type BaseTy,
@@ -187,8 +158,12 @@ static bool isMemberDeclAppliedInternal(const DeclContext *DC, Type BaseTy,
 
   SubstitutionMap substMap = BaseTy->getContextSubstitutionMap(
       DC->getParentModule(), VD->getDeclContext());
-  return areGenericRequirementsSatisfied(genericSig, substMap,
-                                         /*isExtension=*/false);
+
+  // Note: we treat substitution failure as success, to avoid tripping
+  // up over generic parameters introduced by the declaration itself.
+  return TypeChecker::checkGenericArguments(
+      genericSig, QuerySubstitutionMap{substMap})
+      != RequirementCheckResult::Failure;
 }
 
 bool

lib/Sema/TypeCheckAttr.cpp

@@ -2798,22 +2798,16 @@ TypeEraserHasViableInitRequest::evaluate(Evaluator &evaluator,
         typeEraser->getContextSubstitutionMap(nominalTypeDecl->getParentModule(),
                                               nominalTypeDecl);
     QuerySubstitutionMap getSubstitution{baseMap};
-    auto subMap = SubstitutionMap::get(
-        genericSignature,
-        [&](SubstitutableType *type) -> Type {
-          if (type->isEqual(genericParamType))
-            return protocol->getSelfTypeInContext();
-
-          return getSubstitution(type);
-        },
-        LookUpConformanceInModule(dc->getParentModule()));
 
     // Use invalid 'SourceLoc's to suppress diagnostics.
     auto result = TypeChecker::checkGenericArguments(
-          dc, SourceLoc(), SourceLoc(), typeEraser,
-          genericSignature->getGenericParams(),
-          genericSignature->getRequirements(),
-          QuerySubstitutionMap{subMap});
+          genericSignature,
+          [&](SubstitutableType *type) -> Type {
+            if (type->isEqual(genericParamType))
+              return protocol->getSelfTypeInContext();
+
+            return getSubstitution(type);
+          });
 
     if (result != RequirementCheckResult::Success) {
       unviable.push_back(

lib/Sema/TypeCheckGeneric.cpp

@@ -870,6 +870,37 @@ RequirementCheckResult TypeChecker::checkGenericArguments(
   return RequirementCheckResult::SubstitutionFailure;
 }
 
+RequirementCheckResult
+TypeChecker::checkGenericArguments(GenericSignature sig,
+                                   TypeSubstitutionFn substitutions) {
+  SmallVector<Requirement, 4> worklist;
+  bool valid = true;
+
+  for (auto req : sig->getRequirements()) {
+    if (auto resolved = req.subst(
+          substitutions,
+          LookUpConformanceInSignature(sig.getPointer()))) {
+      worklist.push_back(*resolved);
+    } else {
+      valid = false;
+    }
+  }
+
+  while (!worklist.empty()) {
+    auto req = worklist.pop_back_val();
+    ArrayRef<Requirement> conditionalRequirements;
+    if (!req.isSatisfied(conditionalRequirements))
+      return RequirementCheckResult::Failure;
+
+    worklist.append(conditionalRequirements.begin(),
+                    conditionalRequirements.end());
+  }
+
+  if (valid)
+    return RequirementCheckResult::Success;
+  return RequirementCheckResult::SubstitutionFailure;
+}
+
 Requirement
 RequirementRequest::evaluate(Evaluator &evaluator,
                              WhereClauseOwner owner,

lib/Sema/TypeChecker.h

@@ -498,6 +498,10 @@ RequirementCheckResult checkGenericArguments(
     ArrayRef<Requirement> requirements, TypeSubstitutionFn substitutions,
     SubstOptions options = None);
 
+/// A lower-level version of the above without diagnostic emission.
+RequirementCheckResult checkGenericArguments(
+    GenericSignature sig, TypeSubstitutionFn substitutions);
+
 bool checkContextualRequirements(GenericTypeDecl *decl,
                                  Type parentTy,
                                  SourceLoc loc,