[Conformance checking] Apply omit-needless-words for near-miss checking.

The differences between Swift 2 and Swift 3 names can be very
significant, when the Swift 2 names have a lot of restated type
information. These differences end up disabling the near-miss
heuristics because the magnitude of the change is so high. Therefore,
apply the omit-needless-words heuristics to the potential witness and
the requirement before scoring them.

Should finish up rdar://problem/25159872 for real.

Author: DougGregor

lib/Sema/MiscDiagnostics.cpp

@@ -2532,13 +2532,10 @@ static OmissionTypeName getTypeNameForOmission(Type type) {
   return "";
 }
 
-/// Attempt to omit needless words from the name of the given declaration.
-static Optional<DeclName> omitNeedlessWords(AbstractFunctionDecl *afd) {
+Optional<DeclName> swift::omitNeedlessWords(AbstractFunctionDecl *afd) {
   auto &Context = afd->getASTContext();
-  if (!Context.LangOpts.WarnOmitNeedlessWords)
-    return None;
 
-  if (afd->isInvalid())
+  if (afd->isInvalid() || isa<DestructorDecl>(afd))
     return None;
 
   DeclName name = afd->getFullName();
@@ -2624,16 +2621,12 @@ static Optional<DeclName> omitNeedlessWords(AbstractFunctionDecl *afd) {
   return DeclName(Context, newBaseName, newArgNames);
 }
 
-/// Attempt to omit needless words from the name of the given declaration.
-static Optional<Identifier> omitNeedlessWords(VarDecl *var) {
+Optional<Identifier> swift::omitNeedlessWords(VarDecl *var) {
   auto &Context = var->getASTContext();
 
   if (var->isInvalid())
     return None;
 
-  if (!Context.LangOpts.WarnOmitNeedlessWords)
-    return None;
-
   if (var->getName().empty())
     return None;
 
@@ -2646,7 +2639,7 @@ static Optional<Identifier> omitNeedlessWords(VarDecl *var) {
 
   // Dig out the type of the variable.
   Type type = var->getInterfaceType()->getReferenceStorageReferent()
-  ->getLValueOrInOutObjectType();
+                ->getLValueOrInOutObjectType();
   while (auto optObjectTy = type->getAnyOptionalObjectType())
     type = optObjectTy;
 
@@ -2674,7 +2667,10 @@ static Optional<Identifier> omitNeedlessWords(VarDecl *var) {
 }
 
 void TypeChecker::checkOmitNeedlessWords(AbstractFunctionDecl *afd) {
-  auto newName = ::omitNeedlessWords(afd);
+  if (!Context.LangOpts.WarnOmitNeedlessWords)
+    return;
+
+  auto newName = omitNeedlessWords(afd);
   if (!newName)
     return;
 
@@ -2685,7 +2681,10 @@ void TypeChecker::checkOmitNeedlessWords(AbstractFunctionDecl *afd) {
 }
 
 void TypeChecker::checkOmitNeedlessWords(VarDecl *var) {
-  auto newName = ::omitNeedlessWords(var);
+  if (!Context.LangOpts.WarnOmitNeedlessWords)
+    return;
+
+  auto newName = omitNeedlessWords(var);
   if (!newName)
     return;
 
@@ -2859,7 +2858,7 @@ void TypeChecker::checkOmitNeedlessWords(ApplyExpr *apply) {
     return;
 
   // Determine whether the callee has any needless words in it.
-  auto newName = ::omitNeedlessWords(afd);
+  auto newName = omitNeedlessWords(afd);
 
   bool renamed;
   if (!newName) {
@@ -2961,7 +2960,7 @@ void TypeChecker::checkOmitNeedlessWords(MemberRefExpr *memberRef) {
     return;
 
   // Check whether any needless words were omitted.
-  auto newName = ::omitNeedlessWords(var);
+  auto newName = omitNeedlessWords(var);
   if (!newName)
     return;
 

lib/Sema/TypeCheckProtocol.cpp

@@ -4188,6 +4188,34 @@ static unsigned scorePotentiallyMatchingNames(DeclName lhs, DeclName rhs,
   return score;
 }
 
+/// Apply omit-needless-words to the given declaration, if possible.
+static Optional<DeclName> omitNeedlessWords(ValueDecl *value) {
+  if (auto func = dyn_cast<AbstractFunctionDecl>(value))
+    return swift::omitNeedlessWords(func);
+  if (auto var = dyn_cast<VarDecl>(value)) {
+    if (auto newName = swift::omitNeedlessWords(var))
+      return DeclName(*newName);
+    return None;
+  }
+  return None;
+}
+
+/// Determine the score between two potentially-matching declarations.
+static unsigned scorePotentiallyMatching(ValueDecl *req, ValueDecl *witness,
+                                         unsigned limit) {
+  DeclName reqName = req->getFullName();
+  DeclName witnessName = witness->getFullName();
+
+  // Apply the omit-needless-words heuristics to both names.
+  if (auto adjustedReqName = ::omitNeedlessWords(req))
+    reqName = *adjustedReqName;
+  if (auto adjustedWitnessName = ::omitNeedlessWords(witness))
+    witnessName = *adjustedWitnessName;
+
+  return scorePotentiallyMatchingNames(reqName, witnessName, isa<FuncDecl>(req),
+                                       limit);
+}
+
 namespace {
   /// Describes actions one could take to suppress a warning about a
   /// nearly-matching witness for an optional requirement.
@@ -4499,10 +4527,8 @@ void TypeChecker::checkConformancesInContext(DeclContext *dc,
       unsigned bestScore = UINT_MAX;
       for (auto req : unsatisfiedReqs) {
         // Score this particular optional requirement.
-        auto score = scorePotentiallyMatchingNames(value->getFullName(),
-                                                   req->getFullName(),
-                                                   isa<FuncDecl>(req),
-                                                   bestScore);
+        auto score = scorePotentiallyMatching(req, value, bestScore);
+
         // If the score is better than the best we've seen, update the best
         // and clear out the list.
         if (score < bestScore) {

lib/Sema/TypeChecker.h

@@ -1848,6 +1848,12 @@ class EncodedDiagnosticMessage {
   const StringRef Message;
 };
 
+/// Attempt to omit needless words from the name of the given declaration.
+Optional<DeclName> omitNeedlessWords(AbstractFunctionDecl *afd);
+
+/// Attempt to omit needless words from the name of the given declaration.
+Optional<Identifier> omitNeedlessWords(VarDecl *var);
+
 } // end namespace swift
 
 #endif

test/decl/protocol/conforms/near_miss_objc.swift

@@ -76,3 +76,31 @@ class C4a : P4 {
   // expected-note@-3{{move 'doSomethingWithPriority(_:d:)' to an extension to silence this warning}}
   // expected-note@-4{{make 'doSomethingWithPriority(_:d:)' private to silence this warning}}{{3-3=private }}
 }
+
+@objc class SomeClass { }
+
+@objc protocol P5 {
+  optional func methodWithInt(_: Int, forSomeClass: SomeClass, dividingDouble: Double)
+  // expected-note@-1{{requirement 'methodWithInt(_:forSomeClass:dividingDouble:)' declared here}}
+}
+
+class C5a : P5 {
+  func method(_: Int, for someClass: SomeClass, dividing double: Double) { }
+  // expected-warning@-1{{instance method 'method(_:for:dividing:)' nearly matches optional requirement 'methodWithInt(_:forSomeClass:dividingDouble:)' of protocol 'P5'}}
+  // expected-note@-2{{rename to 'methodWithInt(_:forSomeClass:dividingDouble:)' to satisfy this requirement}}{{3-3=@objc(methodWithInt:forSomeClass:dividingDouble:) }}{{8-14=methodWithInt}}{{23-26=forSomeClass}}{{49-57=dividingDouble}}
+  // expected-note@-3{{move 'method(_:for:dividing:)' to an extension to silence this warning}}
+  // expected-note@-4{{make 'method(_:for:dividing:)' private to silence this warning}}{{3-3=private }}
+}
+
+@objc protocol P6 {
+  optional func method(_: Int, for someClass: SomeClass, dividing double: Double)
+  // expected-note@-1{{requirement 'method(_:for:dividing:)' declared here}}
+}
+
+class C6a : P6 {
+  func methodWithInt(_: Int, forSomeClass: SomeClass, dividingDouble: Double) { }
+  // expected-warning@-1{{instance method 'methodWithInt(_:forSomeClass:dividingDouble:)' nearly matches optional requirement 'method(_:for:dividing:)' of protocol 'P6'}}
+  // expected-note@-2{{rename to 'method(_:for:dividing:)' to satisfy this requirement}}{{3-3=@objc(method:for:dividing:) }}{{8-21=method}}{{30-30=for }}{{55-55=dividing }}
+  // expected-note@-3{{move 'methodWithInt(_:forSomeClass:dividingDouble:)' to an extension to silence this warning}}
+  // expected-note@-4{{make 'methodWithInt(_:forSomeClass:dividingDouble:)' private to silence this warning}}{{3-3=private }}
+}