AST: Remove FuncDecl::getNaturalArgumentCount(), NFC

Author: slavapestov

include/swift/AST/Decl.h

@@ -4838,35 +4838,13 @@ class AbstractFunctionDecl : public ValueDecl, public DeclContext {
   /// depending on the function context.
   bool argumentNameIsAPIByDefault() const;
 
+  /// \brief Returns the "natural" number of argument clauses taken by this
+  /// function.  This value is one for free-standing functions, and two for
+  /// methods.
   unsigned getNumParameterLists() const {
     return AbstractFunctionDeclBits.NumParameterLists;
   }
 
-  /// \brief Returns the "natural" number of argument clauses taken by this
-  /// function.  This value is always at least one, and it may be more if the
-  /// function is implicitly or explicitly curried.
-  ///
-  /// For example, this function:
-  /// \code
-  ///   func negate(x : Int) -> Int { return -x }
-  /// \endcode
-  /// has a natural argument count of 1 if it is freestanding.  If it is
-  /// a method, it has a natural argument count of 2, as does this
-  /// curried function:
-  /// \code
-  ///   func add(x : Int)(y : Int) -> Int { return x + y }
-  /// \endcode
-  ///
-  /// This value never exceeds the number of chained function types
-  /// in the function's type, but it can be less for functions which
-  /// return a value of function type:
-  /// \code
-  ///   func const(x : Int) -> () -> Int { return { x } } // NAC==1
-  /// \endcode
-  unsigned getNaturalArgumentCount() const {
-    return getNumParameterLists();
-  }
-
   /// \brief Returns the parameter pattern(s) for the function definition that
   /// determine the parameter names bound in the function body.
   ///

include/swift/AST/Expr.h

@@ -2844,8 +2844,6 @@ class AbstractClosureExpr : public Expr, public DeclContext {
     return parameterList ? parameterList : ArrayRef<const ParameterList *>();
   }
 
-  unsigned getNaturalArgumentCount() const { return 1; }
-
   /// \brief Retrieve the result type of this closure.
   Type getResultType() const;
 

lib/AST/ASTVerifier.cpp

@@ -2304,7 +2304,7 @@ struct ASTNodeBase {};
       // If a decl has the Throws bit set, the function type should throw,
       // and vice versa.
       auto fnTy = AFD->getType()->castTo<AnyFunctionType>();
-      for (unsigned i = 1, e = AFD->getNaturalArgumentCount(); i != e; ++i)
+      for (unsigned i = 1, e = AFD->getNumParameterLists(); i != e; ++i)
         fnTy = fnTy->getResult()->castTo<AnyFunctionType>();
 
       if (AFD->hasThrows() != fnTy->getExtInfo().throws()) {

lib/AST/Decl.cpp

@@ -4415,7 +4415,7 @@ Type FuncDecl::getResultType() const {
   if (resultTy->is<ErrorType>())
     return resultTy;
 
-  for (unsigned i = 0, e = getNaturalArgumentCount(); i != e; ++i)
+  for (unsigned i = 0, e = getNumParameterLists(); i != e; ++i)
     resultTy = resultTy->castTo<AnyFunctionType>()->getResult();
 
   if (!resultTy)

lib/Sema/CSApply.cpp

@@ -577,7 +577,7 @@ namespace {
       if (auto func = dyn_cast<AbstractFunctionDecl>(member)) {
         // For functions, close the existential once the function
         // has been fully applied.
-        return func->getNaturalArgumentCount();
+        return func->getNumParameterLists();
       } else {
         // For storage, close the existential either when it's
         // accessed (if it's an rvalue only) or when it is loaded or

lib/Sema/MiscDiagnostics.cpp

@@ -182,7 +182,7 @@ static void diagSyntacticUseRestrictions(TypeChecker &TC, const Expr *E,
       if (expr->getArg()->getType()->hasInOut()) {
         // We need to apply all argument clauses.
         InvalidPartialApplications.insert({
-          fnExpr, {fn->getNaturalArgumentCount(), kind}
+          fnExpr, {fn->getNumParameterLists(), kind}
         });
       }
     }

lib/Sema/TypeCheckDecl.cpp

@@ -4564,7 +4564,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     if (auto func = dyn_cast<FuncDecl>(decl)) {
       if (func->hasDynamicSelf()) {
         type = type->replaceCovariantResultType(subclass,
-                                                func->getNaturalArgumentCount());
+                                                func->getNumParameterLists());
       }
     } else if (isa<ConstructorDecl>(decl)) {
       type = type->replaceCovariantResultType(subclass, /*uncurryLevel=*/2);

lib/Sema/TypeCheckError.cpp

@@ -56,15 +56,15 @@ class AbstractFunction {
     : TheKind(Kind::Function),
       IsRethrows(fn->getAttrs().hasAttribute<RethrowsAttr>()),
       IsProtocolMethod(isProtocolMethod),
-      ParamCount(fn->getNaturalArgumentCount()) {
+      ParamCount(fn->getNumParameterLists()) {
     TheFunction = fn;
   }
 
   explicit AbstractFunction(AbstractClosureExpr *closure)
     : TheKind(Kind::Closure),
       IsRethrows(false),
       IsProtocolMethod(false),
-      ParamCount(closure->getNaturalArgumentCount()) {
+      ParamCount(1) {
     TheClosure = closure;
   }
 
@@ -380,11 +380,6 @@ classifyFunctionByType(Type type, unsigned numArgs) {
   }
 }
 
-template <class T>
-static ThrowingKind classifyFunctionBodyWithoutContext(T *fn) {
-  return classifyFunctionByType(fn->getType(), fn->getNaturalArgumentCount());
-}
-
 /// A class for collecting information about rethrowing functions.
 class ApplyClassifier {
   llvm::DenseMap<void*, ThrowingKind> Cache;
@@ -850,9 +845,8 @@ class Context {
   };
 
 private:
-  template <class T>
-  static Kind getKindForFunctionBody(T *fn) {
-    switch (classifyFunctionBodyWithoutContext(fn)) {
+  static Kind getKindForFunctionBody(Type type, unsigned numArgs) {
+    switch (classifyFunctionByType(type, numArgs)) {
     case ThrowingKind::None:
       return Kind::NonThrowingFunction;
     case ThrowingKind::Invalid:
@@ -885,7 +879,8 @@ class Context {
       result.RethrowsDC = D;
       return result;
     }
-    return Context(getKindForFunctionBody(D));
+    return Context(getKindForFunctionBody(
+        D->getType(), D->getNumParameterLists()));
   }
 
   static Context forInitializer(Initializer *init) {
@@ -908,7 +903,7 @@ class Context {
   }
 
   static Context forClosure(AbstractClosureExpr *E) {
-    auto kind = getKindForFunctionBody(E);
+    auto kind = getKindForFunctionBody(E->getType(), 1);
     if (kind != Kind::Handled && isa<AutoClosureExpr>(E))
       kind = Kind::NonThrowingAutoClosure;
     return Context(kind);