[NFC] CSApply: Delete the now dead 'buildPropertyWrapperFnThunk'

Author: AnthonyLatsis

lib/Sema/CSApply.cpp

@@ -1188,109 +1188,6 @@ namespace {
                                    thunkTy, locator);
     }
 
-    AutoClosureExpr *buildPropertyWrapperFnThunk(
-        Expr *fnRef, FunctionType *fnType, AnyFunctionRef fnDecl, ConcreteDeclRef ref,
-        ArrayRef<AppliedPropertyWrapper> appliedPropertyWrappers) {
-      auto &context = cs.getASTContext();
-      auto paramInfo = fnType->getParams();
-
-      SmallVector<Argument, 4> args;
-
-      auto *innerParams = fnDecl.getParameters();
-      SmallVector<AnyFunctionType::Param, 4> innerParamTypes;
-
-      OptionSet<ParameterList::CloneFlags> options
-        = (ParameterList::Implicit |
-           ParameterList::NamedArguments);
-      auto *outerParams = innerParams->clone(context, options);
-      SmallVector<AnyFunctionType::Param, 4> outerParamTypes;
-
-      unsigned appliedWrapperIndex = 0;
-      for (auto i : indices(*innerParams)) {
-        auto *innerParam = innerParams->get(i);
-        auto *outerParam = outerParams->get(i);
-        auto outerParamType = paramInfo[i].getPlainType();
-
-        Expr *paramRef = new (context) DeclRefExpr(outerParam, DeclNameLoc(),
-                                                   /*implicit=*/true);
-        paramRef->setType(outerParam->isInOut()
-                          ? LValueType::get(outerParamType) : outerParamType);
-        cs.cacheType(paramRef);
-
-        if (innerParam->hasAttachedPropertyWrapper()) {
-          // Rewrite the parameter ref to the backing wrapper initialization
-          // expression.
-          auto appliedWrapper = appliedPropertyWrappers[appliedWrapperIndex++];
-          auto wrapperType = appliedWrapper.wrapperType;
-          auto initKind = appliedWrapper.initKind;
-
-          using ValueKind = AppliedPropertyWrapperExpr::ValueKind;
-          ValueKind valueKind = (initKind == PropertyWrapperInitKind::ProjectedValue ?
-                                 ValueKind::ProjectedValue : ValueKind::WrappedValue);
-
-          paramRef = AppliedPropertyWrapperExpr::create(context, ref, innerParam, SourceLoc(),
-                                                        wrapperType, paramRef, valueKind);
-          cs.cacheExprTypes(paramRef);
-
-          // SILGen knows how to emit property-wrapped parameters, but the
-          // function type needs the backing wrapper type in its param list.
-          innerParamTypes.push_back(AnyFunctionType::Param(
-              paramRef->getType(), innerParam->getArgumentName(),
-              ParameterTypeFlags(), innerParam->getParameterName()));
-        } else {
-          // Rewrite the parameter ref if necessary.
-          if (outerParam->isInOut()) {
-            paramRef = new (context) InOutExpr(SourceLoc(), paramRef,
-                                               outerParamType, /*implicit=*/true);
-          } else if (innerParam->isVariadic()) {
-            assert(outerParamType->isEqual(paramRef->getType()));
-            paramRef = VarargExpansionExpr::createParamExpansion(context, paramRef);
-          }
-          cs.cacheType(paramRef);
-
-          innerParamTypes.push_back(innerParam->toFunctionParam());
-        }
-
-        // The outer parameters are for an autoclosure, which shouldn't have
-        // argument labels.
-        outerParamTypes.push_back(AnyFunctionType::Param(outerParamType,
-                                                         Identifier(),
-                                                         paramInfo[i].getParameterFlags()));
-        outerParam->setInterfaceType(outerParamType->mapTypeOutOfContext());
-
-        Identifier label;
-        if (fnDecl.getAbstractFunctionDecl())
-          label = innerParam->getArgumentName();
-
-        args.emplace_back(SourceLoc(), label, paramRef);
-      }
-
-      // FIXME: Verify ExtInfo state is correct, not working by accident.
-      FunctionType::ExtInfo fnInfo;
-      fnRef->setType(
-          FunctionType::get(innerParamTypes, fnType->getResult(), fnInfo));
-      cs.cacheType(fnRef);
-
-      auto *argList = ArgumentList::createImplicit(context, args);
-      auto *fnCall = CallExpr::createImplicit(context, fnRef, argList);
-      fnCall->setType(fnType->getResult());
-      cs.cacheType(fnCall);
-
-      auto discriminator = AutoClosureExpr::InvalidDiscriminator;
-
-      // FIXME: Verify ExtInfo state is correct, not working by accident.
-      FunctionType::ExtInfo closureInfo;
-      auto *autoClosureType =
-          FunctionType::get(outerParamTypes, fnType->getResult(), closureInfo);
-      auto *autoClosure = new (context)
-          AutoClosureExpr(fnCall, autoClosureType, discriminator, dc);
-      autoClosure->setParameterList(outerParams);
-      autoClosure->setThunkKind(AutoClosureExpr::Kind::SingleCurryThunk);
-      cs.cacheType(autoClosure);
-
-      return autoClosure;
-    }
-
     AutoClosureExpr *buildCurryThunk(ValueDecl *member,
                                      FunctionType *selfFnTy,
                                      Expr *selfParamRef,