AST: Replace remaining uses of FunctionType::getInput() with getParams()

Author: slavapestov

include/swift/AST/Decl.h

@@ -5954,9 +5954,6 @@ class ConstructorDecl : public AbstractFunctionDecl {
   SourceLoc getStartLoc() const { return getConstructorLoc(); }
   SourceRange getSourceRange() const;
 
-  /// getArgumentInterfaceType - get the interface type of the argument tuple
-  Type getArgumentInterfaceType() const;
-
   /// \brief Get the interface type of the constructed object.
   Type getResultInterfaceType() const;
 

lib/AST/Decl.cpp

@@ -5765,7 +5765,9 @@ Type EnumElementDecl::getArgumentInterfaceType() const {
 
   auto funcTy = interfaceType->castTo<AnyFunctionType>();
   funcTy = funcTy->getResult()->castTo<FunctionType>();
-  return funcTy->getInput();
+  return AnyFunctionType::composeInput(funcTy->getASTContext(),
+                                       funcTy->getParams(),
+                                       /*canonicalVararg=*/false);
 }
 
 EnumCaseDecl *EnumElementDecl::getParentCase() const {
@@ -5801,13 +5803,6 @@ SourceRange ConstructorDecl::getSourceRange() const {
   return { getConstructorLoc(), End };
 }
 
-Type ConstructorDecl::getArgumentInterfaceType() const {
-  Type ArgTy = getInterfaceType();
-  ArgTy = ArgTy->castTo<AnyFunctionType>()->getResult();
-  ArgTy = ArgTy->castTo<AnyFunctionType>()->getInput();
-  return ArgTy;
-}
-
 Type ConstructorDecl::getResultInterfaceType() const {
   Type ArgTy = getInterfaceType();
   ArgTy = ArgTy->castTo<AnyFunctionType>()->getResult();

lib/Sema/CSDiag.cpp

@@ -5489,7 +5489,9 @@ bool FailureDiagnosis::visitApplyExpr(ApplyExpr *callExpr) {
         if (locator->getAnchor() == callExpr) {
           auto calleeType = CS.simplifyType(constraint->getSecondType());
           if (auto *fnType = calleeType->getAs<FunctionType>())
-            argType = fnType->getInput();
+            argType = AnyFunctionType::composeInput(fnType->getASTContext(),
+                                                    fnType->getParams(),
+                                                    /*canonicalVararg=*/false);
         }
       }
     }

lib/Sema/CSSimplify.cpp

@@ -2515,7 +2515,9 @@ ConstraintSystem::simplifyConstructionConstraint(
 
   case TypeKind::Tuple: {
     // Tuple construction is simply tuple conversion.
-    Type argType = fnType->getInput();
+    Type argType = AnyFunctionType::composeInput(getASTContext(),
+                                                 fnType->getParams(),
+                                                 /*canonicalVararg=*/false);
     Type resultType = fnType->getResult();
 
     if (matchTypes(resultType, desugarValueType,
@@ -2923,35 +2925,37 @@ ConstraintSystem::simplifyFunctionComponentConstraint(
                                         Type first, Type second,
                                         TypeMatchOptions flags,
                                         ConstraintLocatorBuilder locator) {
-  auto funcTy = simplifyType(first);
+  auto simplified = simplifyType(first);
 
   unsigned unwrapCount = 0;
   if (shouldAttemptFixes()) {
-    while (auto objectTy = funcTy->getOptionalObjectType()) {
-      funcTy = objectTy;
+    while (auto objectTy = simplified->getOptionalObjectType()) {
+      simplified = objectTy;
 
       // Track how many times we do this so that we can record a fix for each.
       ++unwrapCount;
     }
   }
 
-  if (funcTy->isTypeVariableOrMember()) {
+  if (simplified->isTypeVariableOrMember()) {
     if (!flags.contains(TMF_GenerateConstraints))
       return SolutionKind::Unsolved;
 
     addUnsolvedConstraint(
-      Constraint::create(*this, kind, funcTy, second,
+      Constraint::create(*this, kind, simplified, second,
                          getConstraintLocator(locator)));
-  } else if (funcTy->is<FunctionType>()) {
+  } else if (auto *funcTy = simplified->getAs<FunctionType>()) {
     // Equate it to the other type in the constraint.
     Type type;
     ConstraintLocator::PathElementKind locKind;
 
     if (kind == ConstraintKind::FunctionInput) {
-      type = funcTy->castTo<FunctionType>()->getInput();
+      type = AnyFunctionType::composeInput(getASTContext(),
+                                           funcTy->getParams(),
+                                           /*canonicalVararg=*/false);
       locKind = ConstraintLocator::FunctionArgument;
     } else if (kind == ConstraintKind::FunctionResult) {
-      type = funcTy->castTo<FunctionType>()->getResult();
+      type = funcTy->getResult();
       locKind = ConstraintLocator::FunctionResult;
     } else {
       llvm_unreachable("Bad function component constraint kind");
@@ -3330,7 +3334,10 @@ performMemberLookup(ConstraintKind constraintKind, DeclName memberName,
 
       // Only try and favor monomorphic initializers.
       if (!ctor->isGenericContext()) {
-        auto argType = ctor->getArgumentInterfaceType();
+        auto args = ctor->getMethodInterfaceType()
+                        ->castTo<FunctionType>()->getParams();
+        auto argType = AnyFunctionType::composeInput(getASTContext(), args,
+                                                     /*canonicalVarargs=*/false);
         if (argType->isEqual(favoredType))
           if (!decl->getAttrs().isUnavailable(getASTContext()))
             result.FavoredChoice = result.ViableCandidates.size();

lib/Sema/TypeCheckProtocol.cpp

@@ -1758,7 +1758,11 @@ static Type getTypeForDisplay(ModuleDecl *module, ValueDecl *decl) {
 
   // For a constructor, we only care about the parameter types.
   if (auto ctor = dyn_cast<ConstructorDecl>(decl)) {
-    return ctor->getArgumentInterfaceType();
+    return AnyFunctionType::composeInput(module->getASTContext(),
+                                         ctor->getMethodInterfaceType()
+                                             ->castTo<FunctionType>()
+                                             ->getParams(),
+                                         /*canonicalVararg=*/false);
   }
 
   // We have something function-like, so we want to strip off the 'self'.

lib/Sema/TypeChecker.cpp

@@ -192,17 +192,17 @@ DeclName TypeChecker::getObjectLiteralConstructorName(ObjectLiteralExpr *expr) {
 /// unambiguous name.
 Type TypeChecker::getObjectLiteralParameterType(ObjectLiteralExpr *expr,
                                                 ConstructorDecl *ctor) {
-  Type argType = ctor->getArgumentInterfaceType();
-  auto argTuple = argType->getAs<TupleType>();
-  if (!argTuple) return argType;
+  auto params = ctor->getMethodInterfaceType()
+                    ->castTo<FunctionType>()->getParams();
+  SmallVector<AnyFunctionType::Param, 8> newParams;
+  newParams.append(params.begin(), params.end());
 
   auto replace = [&](StringRef replacement) -> Type {
-    SmallVector<TupleTypeElt, 4> elements;
-    elements.append(argTuple->getElements().begin(),
-                    argTuple->getElements().end());
-    elements[0] = TupleTypeElt(elements[0].getType(),
-                               Context.getIdentifier(replacement));
-    return TupleType::get(elements, Context);
+    newParams[0] = AnyFunctionType::Param(newParams[0].getPlainType(),
+                                          Context.getIdentifier(replacement),
+                                          newParams[0].getParameterFlags());
+    return AnyFunctionType::composeInput(Context, newParams,
+                                         /*canonicalVararg=*/false);
   };
 
   switch (expr->getLiteralKind()) {

tools/swift-api-digester/ModuleAnalyzerNodes.cpp

@@ -1080,7 +1080,11 @@ SwiftDeclCollector::constructTypeNode(Type T,
 
     // Still, return type first
     Root->addChild(constructTypeNode(Fun->getResult()));
-    Root->addChild(constructTypeNode(Fun->getInput()));
+
+    auto Input = AnyFunctionType::composeInput(Fun->getASTContext(),
+                                               Fun->getParams(),
+                                               /*canonicalVararg=*/false);
+    Root->addChild(constructTypeNode(Input));
     return Root;
   }