SILGen: Remove uses of AbstractFunctionDecl::getParameterLists()

Author: slavapestov

lib/SILGen/SILGen.cpp

@@ -690,11 +690,7 @@ emitMarkFunctionEscapeForTopLevelCodeGlobals(SILLocation loc,
 
 void SILGenModule::emitAbstractFuncDecl(AbstractFunctionDecl *AFD) {
   // Emit any default argument generators.
-  if (!isa<DestructorDecl>(AFD)) {
-    unsigned paramListIndex = AFD->getDeclContext()->isTypeContext() ? 1 : 0;
-    auto *paramList = AFD->getParameterLists()[paramListIndex];
-    emitDefaultArgGenerators(AFD, paramList);
-  }
+  emitDefaultArgGenerators(AFD, AFD->getParameters());
 
   // If this is a function at global scope, it may close over a global variable.
   // If we're emitting top-level code, then emit a "mark_function_escape" that
@@ -1028,7 +1024,7 @@ SILFunction *SILGenModule::emitLazyGlobalInitializer(StringRef funcName,
   ASTContext &C = M.getASTContext();
   auto *onceBuiltin =
       cast<FuncDecl>(getBuiltinValueDecl(C, C.getIdentifier("once")));
-  auto blockParam = onceBuiltin->getParameterLists()[0]->get(1);
+  auto blockParam = onceBuiltin->getParameters()->get(1);
   auto *type = blockParam->getType()->castTo<FunctionType>();
   Type initType = FunctionType::get(TupleType::getEmpty(C),
                                     TupleType::getEmpty(C), type->getExtInfo());

lib/SILGen/SILGenApply.cpp

@@ -4720,10 +4720,8 @@ static RValue emitApplyAllocatingInitializer(SILGenFunction &SGF,
   bool requiresDowncast = false;
   if (ctor->isRequired() && overriddenSelfType) {
     CanType substResultType = substFormalType;
-    for (unsigned i : range(ctor->getNumParameterLists())) {
-      (void)i;
-      substResultType = cast<FunctionType>(substResultType).getResult();
-    }
+    substResultType = cast<FunctionType>(substResultType).getResult();
+    substResultType = cast<FunctionType>(substResultType).getResult();
 
     if (!substResultType->isEqual(overriddenSelfType))
       requiresDowncast = true;

lib/SILGen/SILGenBridging.cpp

@@ -1601,24 +1601,6 @@ void SILGenFunction::emitForeignToNativeThunk(SILDeclRef thunk) {
   }
   ImportAsMemberStatus memberStatus = fd->getImportAsMemberStatus();
 
-  // Forward the arguments.
-  auto forwardedParameters = fd->getParameterLists();
-
-  // For allocating constructors, 'self' is a metatype, not the 'self' value
-  // formally present in the constructor body.
-  Type allocatorSelfType;
-  if (thunk.kind == SILDeclRef::Kind::Allocator) {
-    allocatorSelfType = forwardedParameters[0]
-      ->getInterfaceType(getASTContext())
-      ->getWithoutSpecifierType();
-    if (F.getGenericEnvironment())
-      allocatorSelfType = F.getGenericEnvironment()
-        ->mapTypeIntoContext(allocatorSelfType);
-    forwardedParameters = forwardedParameters.slice(1);
-  }
-
-  SmallVector<SILValue, 8> params;
-  
   // Introduce indirect returns if necessary.
   // TODO: Handle exploded results? We don't currently need to since the only
   // bridged indirect type is Any.
@@ -1631,14 +1613,25 @@ void SILGenFunction::emitForeignToNativeThunk(SILDeclRef thunk) {
         F.begin()->createFunctionArgument(nativeConv.getSingleSILResultType());
   }
 
-  for (auto *paramList : reversed(forwardedParameters))
-    bindParametersForForwarding(paramList, params);
+  // Forward the arguments.
+  SmallVector<SILValue, 8> params;
+
+  bindParametersForForwarding(fd->getParameters(), params);
+  if (thunk.kind != SILDeclRef::Kind::Allocator)
+    if (auto *selfDecl = fd->getImplicitSelfDecl())
+      bindParameterForForwarding(selfDecl, params);
+
+  // For allocating constructors, 'self' is a metatype, not the 'self' value
+  // formally present in the constructor body.
+  Type allocatorSelfType;
+  if (thunk.kind == SILDeclRef::Kind::Allocator) {
+    auto *selfDecl = fd->getImplicitSelfDecl();
+    allocatorSelfType = F.mapTypeIntoContext(selfDecl->getInterfaceType());
 
-  if (allocatorSelfType) {
     auto selfMetatype =
       CanMetatypeType::get(allocatorSelfType->getCanonicalType());
     auto selfArg = F.begin()->createFunctionArgument(
-        getLoweredLoadableType(selfMetatype), fd->getImplicitSelfDecl());
+        getLoweredLoadableType(selfMetatype), selfDecl);
     params.push_back(selfArg);
   }
 

lib/SILGen/SILGenConstructor.cpp

@@ -86,7 +86,7 @@ static void emitImplicitValueConstructor(SILGenFunction &SGF,
   RegularLocation Loc(ctor);
   Loc.markAutoGenerated();
   // FIXME: Handle 'self' along with the other arguments.
-  auto *paramList = ctor->getParameterList(1);
+  auto *paramList = ctor->getParameters();
   auto *selfDecl = ctor->getImplicitSelfDecl();
   auto selfTyCan = selfDecl->getType();
   auto selfIfaceTyCan = selfDecl->getInterfaceType();
@@ -231,7 +231,8 @@ void SILGenFunction::emitValueConstructor(ConstructorDecl *ctor) {
   SILValue selfLV = VarLocs[selfDecl].value;
 
   // Emit the prolog.
-  emitProlog(ctor->getParameterList(1),
+  emitProlog(ctor->getParameters(),
+             /*selfParam=*/nullptr,
              ctor->getResultInterfaceType(), ctor,
              ctor->hasThrows());
   emitConstructorMetatypeArg(*this, ctor);
@@ -464,7 +465,7 @@ void SILGenFunction::emitClassConstructorAllocator(ConstructorDecl *ctor) {
   // Forward the constructor arguments.
   // FIXME: Handle 'self' along with the other body patterns.
   SmallVector<SILValue, 8> args;
-  bindParametersForForwarding(ctor->getParameterList(1), args);
+  bindParametersForForwarding(ctor->getParameters(), args);
 
   SILValue selfMetaValue = emitConstructorMetatypeArg(*this, ctor);
 
@@ -595,7 +596,7 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
 
   // Emit the prolog for the non-self arguments.
   // FIXME: Handle self along with the other body patterns.
-  uint16_t ArgNo = emitProlog(ctor->getParameterList(1),
+  uint16_t ArgNo = emitProlog(ctor->getParameters(), /*selfParam=*/nullptr,
                               TupleType::getEmpty(F.getASTContext()), ctor,
                               ctor->hasThrows());
 

lib/SILGen/SILGenExpr.cpp

@@ -4360,7 +4360,7 @@ static bool mayLieAboutNonOptionalReturn(SILModule &M, Expr *expr) {
       // Only consider a full application of a method. Partial applications
       // never lie.
       if (auto func = dyn_cast<AbstractFunctionDecl>(fnRef->getDecl()))
-        if (func->getParameterLists().size() == 1)
+        if (func->getImplicitSelfDecl() == nullptr)
           method = fnRef->getDecl();
     }
     if (method && mayLieAboutNonOptionalReturn(M, method))

lib/SILGen/SILGenFunction.cpp

@@ -390,8 +390,8 @@ SILGenFunction::emitClosureValue(SILLocation loc, SILDeclRef constant,
 void SILGenFunction::emitFunction(FuncDecl *fd) {
   MagicFunctionName = SILGenModule::getMagicFunctionName(fd);
 
-  emitProlog(fd, fd->getParameterLists(), fd->getResultInterfaceType(),
-             fd->hasThrows());
+  emitProlog(fd, fd->getParameters(), fd->getImplicitSelfDecl(),
+             fd->getResultInterfaceType(), fd->hasThrows());
   Type resultTy = fd->mapTypeIntoContext(fd->getResultInterfaceType());
   prepareEpilog(resultTy, fd->hasThrows(), CleanupLocation(fd));
 
@@ -405,8 +405,8 @@ void SILGenFunction::emitClosure(AbstractClosureExpr *ace) {
   MagicFunctionName = SILGenModule::getMagicFunctionName(ace);
 
   auto resultIfaceTy = ace->getResultType()->mapTypeOutOfContext();
-  emitProlog(ace, ace->getParameters(), resultIfaceTy,
-             ace->isBodyThrowing());
+  emitProlog(ace, ace->getParameters(), /*selfParam=*/nullptr,
+             resultIfaceTy, ace->isBodyThrowing());
   prepareEpilog(ace->getResultType(), ace->isBodyThrowing(),
                 CleanupLocation(ace));
   emitProfilerIncrement(ace);
@@ -631,7 +631,8 @@ void SILGenFunction::emitGeneratorFunction(SILDeclRef function, Expr *value) {
 
   auto *dc = function.getDecl()->getInnermostDeclContext();
   auto interfaceType = value->getType()->mapTypeOutOfContext();
-  emitProlog({}, interfaceType, dc, false);
+  emitProlog(/*paramList=*/nullptr, /*selfParam=*/nullptr, interfaceType,
+             dc, false);
   prepareEpilog(value->getType(), false, CleanupLocation::get(Loc));
   emitReturnExpr(Loc, value);
   emitEpilog(Loc);

lib/SILGen/SILGenFunction.h

@@ -657,14 +657,19 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// emitProlog - Generates prolog code to allocate and clean up mutable
   /// storage for closure captures and local arguments.
   void emitProlog(AnyFunctionRef TheClosure,
-                  ArrayRef<ParameterList *> paramPatterns, Type resultType,
-                  bool throws);
+                  ParameterList *paramList, ParamDecl *selfParam,
+                  Type resultType, bool throws);
   /// returns the number of variables in paramPatterns.
-  uint16_t emitProlog(ArrayRef<ParameterList *> paramPatterns, Type resultType,
-                      DeclContext *DeclCtx, bool throws);
+  uint16_t emitProlog(ParameterList *paramList, ParamDecl *selfParam,
+                      Type resultType, DeclContext *DeclCtx, bool throws);
+
+  /// Create SILArguments in the entry block that bind a single value
+  /// of the given parameter suitably for being forwarded.
+  void bindParameterForForwarding(ParamDecl *param,
+                                  SmallVectorImpl<SILValue> &parameters);
 
   /// Create SILArguments in the entry block that bind all the values
-  /// of the given pattern suitably for being forwarded.
+  /// of the given parameter list suitably for being forwarded.
   void bindParametersForForwarding(const ParameterList *params,
                                    SmallVectorImpl<SILValue> &parameters);
 

lib/SILGen/SILGenProlog.cpp

@@ -335,14 +335,18 @@ static void makeArgument(Type ty, ParamDecl *decl,
 }
 
 
+void SILGenFunction::bindParameterForForwarding(ParamDecl *param,
+                                     SmallVectorImpl<SILValue> &parameters) {
+  Type type = (param->hasType()
+               ? param->getType()
+               : F.mapTypeIntoContext(param->getInterfaceType()));
+  makeArgument(type->eraseDynamicSelfType(), param, parameters, *this);
+}
+
 void SILGenFunction::bindParametersForForwarding(const ParameterList *params,
                                      SmallVectorImpl<SILValue> &parameters) {
-  for (auto param : *params) {
-    Type type = (param->hasType()
-                 ? param->getType()
-                 : F.mapTypeIntoContext(param->getInterfaceType()));
-    makeArgument(type->eraseDynamicSelfType(), param, parameters, *this);
-  }
+  for (auto param : *params)
+    bindParameterForForwarding(param, parameters);
 }
 
 static void emitCaptureArguments(SILGenFunction &SGF,
@@ -431,9 +435,10 @@ static void emitCaptureArguments(SILGenFunction &SGF,
 }
 
 void SILGenFunction::emitProlog(AnyFunctionRef TheClosure,
-                                ArrayRef<ParameterList*> paramPatterns,
+                                ParameterList *paramList,
+                                ParamDecl *selfParam,
                                 Type resultType, bool throws) {
-  uint16_t ArgNo = emitProlog(paramPatterns, resultType,
+  uint16_t ArgNo = emitProlog(paramList, selfParam, resultType,
                               TheClosure.getAsDeclContext(), throws);
 
   // Emit the capture argument variables. These are placed last because they
@@ -485,8 +490,10 @@ static void emitIndirectResultParameters(SILGenFunction &SGF, Type resultType,
   (void)arg;
 }
 
-uint16_t SILGenFunction::emitProlog(ArrayRef<ParameterList *> paramLists,
-                                    Type resultType, DeclContext *DC,
+uint16_t SILGenFunction::emitProlog(ParameterList *paramList,
+                                    ParamDecl *selfParam,
+                                    Type resultType,
+                                    DeclContext *DC,
                                     bool throws) {
   // Create the indirect result parameters.
   auto *genericSig = DC->getGenericSignatureOfContext();
@@ -497,12 +504,13 @@ uint16_t SILGenFunction::emitProlog(ArrayRef<ParameterList *> paramLists,
   // Emit the argument variables in calling convention order.
   ArgumentInitHelper emitter(*this, F);
 
-  for (ParameterList *paramList : reversed(paramLists)) {
-    // Add the SILArguments and use them to initialize the local argument
-    // values.
-    for (auto &param : *paramList)
+  // Add the SILArguments and use them to initialize the local argument
+  // values.
+  if (paramList)
+    for (auto *param : *paramList)
       emitter.emitParam(param);
-  }
+  if (selfParam)
+    emitter.emitParam(selfParam);
 
   // Record the ArgNo of the artificial $error inout argument. 
   unsigned ArgNo = emitter.getNumArgs();