Address review feedback

Author: aschwaighofer

lib/Sema/TypeCheckConstraints.cpp

@@ -1015,7 +1015,7 @@ bool PreCheckExpression::walkToClosureExprPre(ClosureExpr *closure) {
 
   GenericTypeToArchetypeResolver resolver(closure);
 
-  if (TC.typeCheckParameterList(PL, DC, options, resolver, true)) {
+  if (TC.typeCheckParameterList(PL, DC, options, resolver)) {
     closure->setType(ErrorType::get(TC.Context));
 
     // If we encounter an error validating the parameter list, don't bail.

lib/Sema/TypeCheckDecl.cpp

@@ -4354,8 +4354,9 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     TypeResolutionOptions options;
     options |= TypeResolutionFlags::SubscriptParameters;
 
-    isInvalid |= TC.typeCheckParameterList(SD->getIndices(), SD, options,
-                                           resolver, false);
+    isInvalid |= TC.typeCheckParameterList(SD->getIndices(), SD,
+                                           options,
+                                           resolver);
 
     if (isInvalid || SD->isInvalid()) {
       SD->setInterfaceType(ErrorType::get(TC.Context));
@@ -4905,8 +4906,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
                              GenericTypeResolver &resolver) {
     bool hadError = false;
     for (auto paramList : fd->getParameterLists()) {
-      hadError |= TC.typeCheckParameterList(
-          paramList, fd, TypeResolutionOptions(), resolver, fd->hasBody());
+      hadError |= TC.typeCheckParameterList(paramList, fd,
+                                            TypeResolutionOptions(), resolver);
     }
 
     return hadError;

lib/Sema/TypeCheckGeneric.cpp

@@ -506,7 +506,7 @@ static bool checkGenericFuncSignature(TypeChecker &tc,
   for (auto params : func->getParameterLists()) {
     // Check the pattern.
     if (tc.typeCheckParameterList(params, func, TypeResolutionOptions(),
-                                  resolver, func->hasBody()))
+                                  resolver))
       badType = true;
 
     // Infer requirements from the pattern.
@@ -1004,8 +1004,9 @@ static bool checkGenericSubscriptSignature(TypeChecker &tc,
   auto params = subscript->getIndices();
   TypeResolutionOptions options = TypeResolutionFlags::SubscriptParameters;
 
-  badType |=
-      tc.typeCheckParameterList(params, subscript, options, resolver, false);
+  badType |= tc.typeCheckParameterList(params, subscript,
+                                       options,
+                                       resolver);
 
   // Infer requirements from the pattern.
   if (builder) {

lib/Sema/TypeCheckPattern.cpp

@@ -780,26 +780,21 @@ static bool validateParameterType(ParamDecl *decl, DeclContext *DC,
 void TypeChecker::requestRequiredNominalTypeLayoutForParameters(
     ParameterList *PL) {
   for (auto param : *PL) {
-    auto type = param->hasType() ? param->getType()->getCanonicalType()
-                                 : param->getTypeLoc().getType();
-    if (!type)
-      continue;
-    if (auto *generic = dyn_cast<BoundGenericType>(type.getPointer())) {
-      // Generic types are sources for typemetadata and conformances. If a
-      // parameter is of dependent type then the body of a function with said
-      // parameter could potentially require the generic type's layout to
-      // recover them.
-      if (auto *nominalDecl = dyn_cast<NominalTypeDecl>(generic->getDecl())) {
-        requestNominalLayout(nominalDecl);
-      }
+    // Generic types are sources for typemetadata and conformances. If a
+    // parameter is of dependent type then the body of a function with said
+    // parameter could potentially require the generic type's layout to
+    // recover them.
+    if (auto *nominalDecl = dyn_cast_or_null<NominalTypeDecl>(
+            param->getType()->getAnyGeneric())) {
+      requestNominalLayout(nominalDecl);
     }
   }
 }
 
 /// Type check a parameter list.
-bool TypeChecker::typeCheckParameterList(
-    ParameterList *PL, DeclContext *DC, TypeResolutionOptions options,
-    GenericTypeResolver &resolver, bool bodyCouldRequireTypeOrConformance) {
+bool TypeChecker::typeCheckParameterList(ParameterList *PL, DeclContext *DC,
+                                         TypeResolutionOptions options,
+                                         GenericTypeResolver &resolver) {
   bool hadError = false;
 
   for (auto param : *PL) {
@@ -844,9 +839,6 @@ bool TypeChecker::typeCheckParameterList(
       }
     }
   }
-
-  if (!hadError && bodyCouldRequireTypeOrConformance)
-    requestRequiredNominalTypeLayoutForParameters(PL);
 
   return hadError;
 }

lib/Sema/TypeCheckStmt.cpp

@@ -1426,6 +1426,9 @@ bool TypeChecker::typeCheckAbstractFunctionBody(AbstractFunctionDecl *AFD) {
   if (DebugTimeFunctionBodies || WarnLongFunctionBodies)
     timer.emplace(AFD, DebugTimeFunctionBodies, WarnLongFunctionBodies);
 
+  for (auto paramList : AFD->getParameterLists())
+    requestRequiredNominalTypeLayoutForParameters(paramList);
+
   if (typeCheckAbstractFunctionBodyUntil(AFD, SourceLoc()))
     return true;
 

lib/Sema/TypeChecker.h

@@ -1816,9 +1816,8 @@ class TypeChecker final : public LazyResolver {
   /// Type check a parameter list.
   bool typeCheckParameterList(ParameterList *PL, DeclContext *dc,
                               TypeResolutionOptions options,
-                              GenericTypeResolver &resolver,
-                              bool bodyCouldRequireTypeOrConformance);
-  
+                              GenericTypeResolver &resolver);
+
   /// Coerce a pattern to the given type.
   ///
   /// \param P The pattern, which may be modified by this coercion.