[Overload resolution] Prefer functions with fewer defaulted/variadic arguments.

When comparing two functions for overload resolution, break apart the
parameter lists to compare individual parameters rather than comparing
the tuples. This allows us to prefer functions with fewer arguments to
ones with more, defaulted or variadic arguments. That preference was
already encoded in the constraint optimizer, which led to some strange
behavior where the preference was expressed for function calls but not
for calls to initializers. Fixes rdar://problem/24128153.

The standard library change tweaks the anachronistic, unavailable
"print" variants somewhat. The only behavior change here is a slight
regression for cases like:

  print(a: 1, b: 2)

where we used to produce a diagnostic:

  Please wrap your tuple argument in parentheses: 'print((...))'

but we now get:

  argument labels '(a:, b:)' do not match any available overloads

However, this regression will happen at some point *anyway*, if
SE-0029 (or anything else that removes the implicit tuple splat
operation) goes through.

Author: DougGregor

lib/Sema/CSRanking.cpp

@@ -469,19 +469,6 @@ static bool isProtocolExtensionAsSpecializedAs(TypeChecker &tc,
   return cs.solveSingle().hasValue();
 }
 
-/// Count the number of default arguments in the primary clause.
-static unsigned countDefaultArguments(AbstractFunctionDecl *func) {
-  auto paramList = func->getParameterList(func->getImplicitSelfDecl() != 0);
-
-  unsigned count = 0;
-  for (auto elt : *paramList) {
-    if (elt->isDefaultArgument())
-      ++count;
-  }
-
-  return count;
-}
-
 /// \brief Determine whether the first declaration is as "specialized" as
 /// the second declaration.
 ///
@@ -646,6 +633,7 @@ static bool isDeclAsSpecializedAs(TypeChecker &tc, DeclContext *dc,
         break;
       }
 
+      bool fewerEffectiveParameters = false;
       switch (checkKind) {
       case CheckAll:
         // Check whether the first type is a subtype of the second.
@@ -660,40 +648,60 @@ static bool isDeclAsSpecializedAs(TypeChecker &tc, DeclContext *dc,
         // second type's inputs, i.e., can we forward the arguments?
         auto funcTy1 = openedType1->castTo<FunctionType>();
         auto funcTy2 = openedType2->castTo<FunctionType>();
-        cs.addConstraint(ConstraintKind::Subtype,
-                         funcTy1->getInput(),
-                         funcTy2->getInput(),
-                         locator);
+        SmallVector<CallArgParam, 4> params1 =
+          decomposeArgParamType(funcTy1->getInput());
+        SmallVector<CallArgParam, 4> params2 =
+          decomposeArgParamType(funcTy2->getInput());
+
+        unsigned numParams1 = params1.size();
+        unsigned numParams2 = params2.size();
+        if (numParams1 > numParams2) return false;
+
+        for (unsigned i = 0; i != numParams2; ++i) {
+          // If there is no corresponding argument in the first
+          // parameter list...
+          if (i >= numParams1) {
+            // We need either a default argument or a variadic
+            // argument for the first declaration to be more
+            // specialized.
+            if (!params2[i].HasDefaultArgument && !params2[i].Variadic)
+              return false;
+
+            fewerEffectiveParameters = true;
+            continue;
+          }
+
+          // Labels must match.
+          if (params1[i].Label != params2[i].Label) return false;
+
+          // If one parameter is variadic and the other is not...
+          if (params1[i].Variadic != params2[i].Variadic) {
+            // If the first parameter is the variadic one, it's not
+            // more specialized.
+            if (params1[i].Variadic) return false;
+
+            fewerEffectiveParameters = true;
+          }
+
+          // Check whether the first parameter is a subtype of the second.
+          cs.addConstraint(ConstraintKind::Subtype,
+                           params1[i].Ty, params2[i].Ty, locator);
+        }
+
         break;
       }
       }
 
       // Solve the system.
       auto solution = cs.solveSingle(FreeTypeVariableBinding::Allow);
 
-
       // Ban value-to-optional conversions.
       if (solution && solution->getFixedScore().Data[SK_ValueToOptional] == 0)
         return true;
 
-      // Between two imported functions/methods, prefer one with fewer
-      // defaulted arguments.
-      //
-      // FIXME: This is a total hack; we should be comparing based on the
-      // number of default arguments at were actually used. It's only safe to
-      // do this because the count will be zero except when under the
-      // experimental InferDefaultArguments mode of the Clang importer.
-      if (isa<AbstractFunctionDecl>(decl1) && 
-          isa<AbstractFunctionDecl>(decl2) &&
-          decl1->getClangDecl() && 
-          decl2->getClangDecl()) {
-        unsigned defArgsIn1
-          = countDefaultArguments(cast<AbstractFunctionDecl>(decl1));
-        unsigned defArgsIn2
-          = countDefaultArguments(cast<AbstractFunctionDecl>(decl2));
-        if (defArgsIn1 < defArgsIn2)
-          return true;
-      }
+      // If the first function has fewer effective parameters than the
+      // second, it is more specialized.
+      if (fewerEffectiveParameters) return true;
 
       return false;
     };

stdlib/public/core/Print.swift

@@ -154,15 +154,10 @@ internal func _debugPrint<Target: OutputStreamType>(
 //===----------------------------------------------------------------------===//
 //===--- Migration Aids ---------------------------------------------------===//
 
-@available(*, unavailable, message="Please wrap your tuple argument in parentheses: 'print((...))'")
-public func print<T>(_: T) {}
-@available(*, unavailable, message="Please wrap your tuple argument in parentheses: 'debugPrint((...))'")
-public func debugPrint<T>(_: T) {}
-
 @available(*, unavailable, message="Please use 'terminator: \"\"' instead of 'appendNewline: false': 'print((...), terminator: \"\")'")
-public func print<T>(_: T, appendNewline: Bool) {}
+public func print<T>(_: T, appendNewline: Bool = true) {}
 @available(*, unavailable, message="Please use 'terminator: \"\"' instead of 'appendNewline: false': 'debugPrint((...), terminator: \"\")'")
-public func debugPrint<T>(_: T, appendNewline: Bool) {}
+public func debugPrint<T>(_: T, appendNewline: Bool = true) {}
 
 
 //===--- FIXME: Not working due to <rdar://22101775> ----------------------===//
@@ -172,10 +167,10 @@ public func print<T>(_: T, inout _: OutputStreamType) {}
 public func debugPrint<T>(_: T, inout _: OutputStreamType) {}
 
 @available(*, unavailable, message="Please use 'terminator: \"\"' instead of 'appendNewline: false' and use the 'toStream' label for the target stream: 'print((...), terminator: \"\", toStream: &...)'")
-public func print<T>(_: T, inout _: OutputStreamType, appendNewline: Bool) {}
+public func print<T>(_: T, inout _: OutputStreamType, appendNewline: Bool = true) {}
 @available(*, unavailable, message="Please use 'terminator: \"\"' instead of 'appendNewline: false' and use the 'toStream' label for the target stream: 'debugPrint((...), terminator: \"\", toStream: &...)'")
 public func debugPrint<T>(
-  _: T, inout _: OutputStreamType, appendNewline: Bool
+  _: T, inout _: OutputStreamType, appendNewline: Bool = true
 ) {}
 //===----------------------------------------------------------------------===//
 //===----------------------------------------------------------------------===//

test/1_stdlib/PrintDiagnostics.swift

@@ -9,4 +9,5 @@ print(3, &stream) // expected-error{{'&' used with non-inout argument of type 'A
 debugPrint(3, &stream) // expected-error{{'&' used with non-inout argument of type 'Any'}}
 print(3, &stream, appendNewline: false) // expected-error {{cannot pass immutable value as inout argument: implicit conversion from 'String' to 'OutputStreamType' requires a temporary}}
 debugPrint(3, &stream, appendNewline: false) // expected-error {{cannot pass immutable value as inout argument: implicit conversion from 'String' to 'OutputStreamType' requires a temporary}} 
-print(4, quack: 5) // expected-error {{'print' is unavailable: Please wrap your tuple argument in parentheses: 'print((...))'}}
+print(4, quack: 5) // expected-error {{argument labels '(_:, quack:)' do not match any available overloads}}
+// expected-note@-1{{overloads for 'print' exist with these partially matching parameter lists: (Any..., separator: String, terminator: String), (T, appendNewline: Bool), (T, inout OutputStreamType), (T, inout OutputStreamType, appendNewline: Bool)}}

test/Constraints/diagnostics.swift

@@ -282,9 +282,10 @@ func rdar21784170() {
 }
 
 // <rdar://problem/21829141> BOGUS: unexpected trailing closure
-func expect<T, U>(_: T) -> (U.Type) -> () { return { ty in () } } // expected-note{{found this candidate}}
-func expect<T, U>(_: T, _: Int = 1) -> (U.Type) -> () { return { ty in () } } // expected-note{{found this candidate}}
-expect(Optional(3))(Optional<Int>.self) // expected-error{{ambiguous use of 'expect'}}
+func expect<T, U>(_: T) -> (U.Type) -> Int { return { a in 0 } }
+func expect<T, U>(_: T, _: Int = 1) -> (U.Type) -> String { return { a in "String" } }
+let expectType1 = expect(Optional(3))(Optional<Int>.self)
+let expectType1Check: Int = expectType1
 
 // <rdar://problem/19804707> Swift Enum Scoping Oddity
 func rdar19804707() {

test/Constraints/function.swift

@@ -67,8 +67,7 @@ class A {
   func a(text:String, something:Int?=nil) {
   }
 }
-A().a(text:"sometext") // expected-error {{argument labels '(text:)' do not match any available overloads}}
-// expected-note @-1 {{overloads for 'a' exist with these partially matching parameter lists: (String), (String, something: Int?)}}
+A().a(text:"sometext") // expected-error{{extraneous argument label 'text:' in call}}{{7-12=}}
 
 
 // <rdar://problem/22451001> QoI: incorrect diagnostic when argument to print has the wrong type

test/Constraints/overload.swift

@@ -133,3 +133,31 @@ func test_contextual_result() {
   return overloaded_identity()  // expected-error {{no 'overloaded_identity' candidates produce the expected contextual result type '()'}}
   // expected-note @-1 {{overloads for 'overloaded_identity' exist with these result types: Int, Float}}
 }
+
+// rdar://problem/24128153
+struct X0 {
+  init(_ i: Any.Type) { }
+  init?(_ i: Any.Type, _ names: String...) { }
+}
+
+let x0 = X0(Int.self)
+let x0check: X0 = x0 // okay: chooses first initializer
+
+struct X1 {
+  init?(_ i: Any.Type) { }
+  init(_ i: Any.Type, _ names: String...) { }
+}
+
+let x1 = X1(Int.self)
+let x1check: X1 = x1 // expected-error{{value of optional type 'X1?' not unwrapped; did you mean to use '!' or '?'?}}
+
+
+struct X2 {
+  init?(_ i: Any.Type) { }
+  init(_ i: Any.Type, a: Int = 0) { }
+  init(_ i: Any.Type, a: Int = 0, b: Int = 0) { }
+  init(_ i: Any.Type, a: Int = 0, c: Int = 0) { }
+}
+
+let x2 = X2(Int.self)
+let x2check: X2 = x2 // expected-error{{value of optional type 'X2?' not unwrapped; did you mean to use '!' or '?'?}}