Sema: Simplify GenericSignatureRequest::evaluate()

Author: slavapestov

lib/Sema/TypeCheckGeneric.cpp

@@ -488,7 +488,7 @@ static void collectAdditionalExtensionRequirements(
     type = type->getCanonicalType();
 
   // A parameterized protocol type is not a nominal. Unwrap it to get
-  // the underlying nominal, and record a same-type requirement for
+  // the underlying nominal, and record same-type requirements for
   // the primary associated types.
   if (auto *paramProtoTy = type->getAs<ParameterizedProtocolType>()) {
     auto *protoTy = paramProtoTy->getBaseType();
@@ -569,24 +569,24 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
     return sig;
   }
 
+  if (auto accessor = dyn_cast<AccessorDecl>(GC))
+    if (auto subscript = dyn_cast<SubscriptDecl>(accessor->getStorage()))
+       return subscript->getGenericSignature();
+
   bool allowConcreteGenericParams = false;
   auto *genericParams = GC->getGenericParams();
   const auto *where = GC->getTrailingWhereClause();
 
+  if (!genericParams && !where) {
+    // We can fast-path computing the generic signature of non-generic
+    // declarations by re-using the parent context's signature.
+    return GC->getParentForLookup()->getGenericSignatureOfContext();
+  }
+
   if (genericParams) {
     // Setup the depth of the generic parameters.
     const_cast<GenericParamList *>(genericParams)
         ->setDepth(GC->getGenericContextDepth());
-
-    // Accessors can always use the generic context of their storage
-    // declarations. This is a compile-time optimization since it lets us
-    // avoid the requirements-gathering phase, but it also simplifies that
-    // work for accessors which don't mention the value type in their formal
-    // signatures (like the read and modify coroutines, since yield types
-    // aren't tracked in the AST type yet).
-    if (auto accessor = dyn_cast<AccessorDecl>(GC->getAsDecl())) {
-      return cast<SubscriptDecl>(accessor->getStorage())->getGenericSignature();
-    }
   }
 
   // ...or we may only have a contextual where clause.
@@ -605,28 +605,20 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
   if (!genericParams && where)
     allowConcreteGenericParams = true;
 
-  if (!genericParams && !where) {
-    // We can fast-path computing the generic signature of non-generic
-    // declarations by re-using the parent context's signature.
-    if (auto accessor = dyn_cast<AccessorDecl>(GC->getAsDecl()))
-      if (auto subscript = dyn_cast<SubscriptDecl>(accessor->getStorage()))
-         return subscript->getGenericSignature();
-
-    return GC->getParentForLookup()->getGenericSignatureOfContext();
-  }
-
   GenericSignature parentSig;
   SmallVector<TypeLoc, 2> inferenceSources;
   SmallVector<Requirement, 2> sameTypeReqs;
-  if (auto VD = dyn_cast_or_null<ValueDecl>(GC->getAsDecl())) {
+  if (auto VD = dyn_cast<ValueDecl>(GC->getAsDecl())) {
     parentSig = GC->getParentForLookup()->getGenericSignatureOfContext();
 
     auto func = dyn_cast<AbstractFunctionDecl>(VD);
     auto subscr = dyn_cast<SubscriptDecl>(VD);
     auto macro = dyn_cast<MacroDecl>(VD);
+    assert(func || subscr || macro || isa<NominalTypeDecl>(VD) ||
+           isa<TypeAliasDecl>(VD));
 
     // For functions and subscripts, resolve the parameter and result types and
-    // note them as inference sources.
+    // note them as requirement inference sources.
     if (subscr || func || (macro && macro->parameterList)) {
       const auto baseOptions =
           TypeResolutionOptions(func ? TypeResolverContext::AbstractFunctionDecl
@@ -688,14 +680,16 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
     genericParams = nullptr;
 
     collectAdditionalExtensionRequirements(ext->getExtendedType(), sameTypeReqs);
-    
-   // Re-use the signature of the type being extended by default.
+
+    // Re-use the signature of the type being extended by default.
     if (sameTypeReqs.empty() && !ext->getTrailingWhereClause()) {
       return parentSig;
     }
 
-    // Allow parameters to be equated with concrete types.
+    // Extensions allow parameters to be equated with concrete types.
     allowConcreteGenericParams = true;
+  } else {
+    llvm_unreachable("Unknown generic declaration kind");
   }
 
   auto request = InferredGenericSignatureRequest{