[Constraint solver] Match argument labels for unresolved member expressions.

Author: DougGregor

lib/Sema/CSGen.cpp

@@ -3607,6 +3607,14 @@ namespace {
         return { true, expr };
       }
 
+      if (auto unresolvedMember = dyn_cast<UnresolvedMemberExpr>(expr)) {
+        associateArgumentLabels(unresolvedMember,
+                                { unresolvedMember->getArgumentLabels(),
+                                  unresolvedMember->hasTrailingClosure() },
+                                /*labelsArePermanent=*/true);
+        return { true, expr };
+      }
+
       // FIXME: other expressions have argument labels, but this is an
       // optimization, so stage it in later.
       return { true, expr };

test/Constraints/generics.swift

@@ -630,7 +630,7 @@ let arr = [BottleLayout]()
 let layout = BottleLayout(count:1)
 let ix = arr.firstIndex(of:layout) // expected-error {{argument type 'BottleLayout' does not conform to expected type 'Equatable'}}
 
-let _: () -> UInt8 = { .init("a" as Unicode.Scalar) } // expected-error {{missing argument label 'ascii:' in call}}
+let _: () -> UInt8 = { .init("a" as Unicode.Scalar) } // expected-error {{initializer 'init(_:)' requires that 'Unicode.Scalar' conform to 'BinaryInteger'}}
 
 // https://bugs.swift.org/browse/SR-9068
 func compare<C: Collection, Key: Hashable, Value: Equatable>(c: C)

test/Constraints/overload_filtering.swift

@@ -19,6 +19,10 @@ struct X {
   subscript(_: Int) -> Int { return 0 }
   subscript(_: Int, _: Int) -> Double { return 0 }
   subscript(_: Int, _: Int, _: Int) -> String { return "" }
+
+  init(_: Int) { }
+  init(_: Int, _: Int) { }
+  init(_: Int, _: Int, _: Int) { }
 }
 
 func testSubscript(x: X, i: Int) {
@@ -28,3 +32,10 @@ func testSubscript(x: X, i: Int) {
   // CHECK-NEXT: introducing single enabled disjunction term {{.*}} bound to decl overload_filtering.(file).X.subscript(_:_:)
   _ = x[i, i]
 }
+
+func testUnresolvedMember(i: Int) -> X {
+  // CHECK: disabled disjunction term {{.*}} bound to decl overload_filtering.(file).X.init(_:)
+  // CHECK-NEXT: disabled disjunction term {{.*}} bound to decl overload_filtering.(file).X.init(_:_:_:)
+  // CHECK-NEXT: introducing single enabled disjunction term {{.*}} bound to decl overload_filtering.(file).X.init(_:_:)
+  return .init(i, i)
+}

test/Constraints/patterns.swift

@@ -291,7 +291,9 @@ switch staticMembers {
   case .init(0): break
   case .init(_): break // expected-error{{'_' can only appear in a pattern}}
   case .init(let x): break // expected-error{{cannot appear in an expression}}
-  case .init(opt: 0): break // expected-error{{pattern cannot match values of type 'StaticMembers'}}
+case .init(opt: 0): break // expected-error{{value of optional type 'StaticMembers?' must be unwrapped to a value of type 'StaticMembers'}}
+  // expected-note@-1{{force-unwrap using '!' to abort execution if the optional value contains 'nil'}}
+  // expected-note@-2{{coalesce using '??' to provide a default when the optional value contains 'nil'}}
 
   case .prop: break
   // TODO: repeated error message