Allow instance member syntax in @available(renamed:).

Example:

    @available(*, unavailable, renamed: "Sequence.enumerated(self:)")
    func enumerate<Seq: SequenceType>(_ sequence: Seq) ->
        EnumerateSequence<Seq>

This will allow us to reuse this logic to suggest fixes for APIs
turned into members by NS_SWIFT_NAME.

Author: jrose-apple

lib/Frontend/DiagnosticVerifier.cpp

@@ -697,7 +697,7 @@ bool swift::verifyDiagnostics(SourceManager &SM, ArrayRef<unsigned> BufferIDs) {
   auto *Verifier = (DiagnosticVerifier*)SM.getLLVMSourceMgr().getDiagContext();
   SM.getLLVMSourceMgr().setDiagHandler(nullptr, nullptr);
 
-  bool autoApplyFixes = false;
+  bool autoApplyFixes = true;
 
   bool HadError = false;
 

lib/Parse/ParseDecl.cpp

@@ -886,8 +886,7 @@ bool Parser::parseNewDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
           Message = Value.getValue();
         } else {
           ParsedDeclName parsedName = parseDeclName(Value.getValue());
-          if (!parsedName || parsedName.isInstanceMember() ||
-              parsedName.isPropertyAccessor()) {
+          if (!parsedName || parsedName.isPropertyAccessor()) {
             diagnose(Loc, diag::attr_availability_invalid_renamed, AttrName);
             DiscardAttribute = true;
             continue;

lib/Sema/MiscDiagnostics.cpp

@@ -1008,16 +1008,97 @@ void swift::fixItAvailableAttrRename(TypeChecker &TC,
                                      const AvailableAttr *attr,
                                      const CallExpr *CE) {
   ParsedDeclName parsed = swift::parseDeclName(attr->Rename);
-  if (!parsed || parsed.isInstanceMember() || parsed.isPropertyAccessor())
+  if (!parsed || parsed.isPropertyAccessor())
     return;
 
-  SmallString<64> baseReplace;
-  if (!parsed.ContextName.empty()) {
-    baseReplace += parsed.ContextName;
-    baseReplace += '.';
+  if (parsed.isInstanceMember()) {
+    // Replace the base of the call with the "self argument".
+    // We can only do a good job with the fix-it if we have the whole call
+    // expression.
+    // FIXME: Should we be validating the ContextName in some way?
+    if (!CE)
+      return;
+    assert(parsed.IsFunctionName && "instance members use function syntax");
+    
+    SourceManager &sourceMgr = TC.Context.SourceMgr;
+
+    unsigned selfIndex = parsed.SelfIndex.getValue();
+    const Expr *selfExpr = nullptr;
+    SourceRange selfArgRange;
+    SourceLoc endOfPreviousArg;
+
+    const Expr *argExpr = CE->getArg();
+    if (auto args = dyn_cast<TupleExpr>(argExpr)) {
+      if (selfIndex >= args->getNumElements() ||
+          parsed.ArgumentLabels.size() != args->getNumElements() - 1) {
+        return;
+      }
+
+      selfExpr = args->getElement(selfIndex);
+      selfArgRange = selfExpr->getSourceRange();
+
+      SourceLoc labelLoc = args->getElementNameLoc(selfIndex);
+      if (labelLoc.isValid())
+        selfArgRange.Start = labelLoc;
+
+      if (selfIndex > 0) {
+        endOfPreviousArg = args->getElement(selfIndex-1)->getEndLoc();
+        endOfPreviousArg = Lexer::getLocForEndOfToken(sourceMgr,
+                                                      endOfPreviousArg);
+      }
+
+      // Avoid later argument label fix-its for this argument.
+      Identifier oldLabel = args->getElementName(selfIndex);
+      StringRef oldLabelStr;
+      if (!oldLabel.empty())
+        oldLabelStr = oldLabel.str();
+      parsed.ArgumentLabels.insert(parsed.ArgumentLabels.begin() + selfIndex,
+                                   oldLabelStr);
+
+    } else {
+      if (selfIndex != 0 || !parsed.ArgumentLabels.empty())
+        return;
+      selfExpr = cast<ParenExpr>(argExpr)->getSubExpr();
+      selfArgRange = argExpr->getSourceRange();
+    }
+
+    if (selfArgRange.Start.isInvalid() || selfArgRange.End.isInvalid())
+      return;
+
+    if (endOfPreviousArg.isInvalid())
+      endOfPreviousArg = selfArgRange.Start;
+
+    CharSourceRange selfExprRange =
+        Lexer::getCharSourceRangeFromSourceRange(sourceMgr,
+                                                 selfExpr->getSourceRange());
+    bool needsParens = !selfExpr->canAppendCallParentheses();
+
+    SmallString<64> selfReplace;
+    if (needsParens)
+      selfReplace.push_back('(');
+    selfReplace += sourceMgr.extractText(selfExprRange);
+    if (needsParens)
+      selfReplace.push_back(')');
+    selfReplace.push_back('.');
+    selfReplace += parsed.BaseName;
+    diag.fixItReplace(CE->getFn()->getSourceRange(), selfReplace);
+
+    diag.fixItRemoveChars(endOfPreviousArg,
+                          Lexer::getLocForEndOfToken(sourceMgr,
+                                                     selfArgRange.End));
+
+    // Continue on to diagnose any argument label renames.
+
+  } else {
+    // Just replace the base name.
+    SmallString<64> baseReplace;
+    if (!parsed.ContextName.empty()) {
+      baseReplace += parsed.ContextName;
+      baseReplace += '.';
+    }
+    baseReplace += parsed.BaseName;
+    diag.fixItReplace(referenceRange, baseReplace);
   }
-  baseReplace += parsed.BaseName;
-  diag.fixItReplace(referenceRange, baseReplace);
 
   if (!CE || !parsed.IsFunctionName)
     return;

test/attr/attr_availability.swift

@@ -337,3 +337,43 @@ func testRenameArgMismatch() {
   unavailableTooManyUnnamed(0) // expected-error{{'unavailableTooManyUnnamed' has been renamed to 'shinyLabeledArguments(a:b:)'}} {{3-28=shinyLabeledArguments}}
   unavailableNoArgsTooMany() // expected-error{{'unavailableNoArgsTooMany()' has been renamed to 'shinyLabeledArguments(a:)'}} {{3-27=shinyLabeledArguments}}
 }
+
+@available(*, unavailable, renamed: "Int.foo(self:)")
+func unavailableInstance(a: Int) {} // expected-note 2 {{here}}
+@available(*, unavailable, renamed: "Int.foo(self:)")
+func unavailableInstanceUnlabeled(_ a: Int) {} // expected-note {{here}}
+@available(*, unavailable, renamed: "Int.foo(self:other:)")
+func unavailableInstanceFirst(a: Int, b: Int) {} // expected-note {{here}}
+@available(*, unavailable, renamed: "Int.foo(other:self:)")
+func unavailableInstanceSecond(a: Int, b: Int) {} // expected-note {{here}}
+@available(*, unavailable, renamed: "Int.foo(_:self:c:)")
+func unavailableInstanceSecondOfThree(a: Int, b: Int, c: Int) {} // expected-note {{here}}
+
+func testRenameInstance() {
+  unavailableInstance(a: 0) // expected-error{{'unavailableInstance(a:)' has been renamed to 'Int.foo(self:)'}} {{3-22=0.foo}} {{23-27=}}
+  unavailableInstanceUnlabeled(0) // expected-error{{'unavailableInstanceUnlabeled' has been renamed to 'Int.foo(self:)'}} {{3-31=0.foo}} {{31-34=}}
+  unavailableInstanceFirst(a: 0, b: 1) // expected-error{{'unavailableInstanceFirst(a:b:)' has been renamed to 'Int.foo(self:other:)'}} {{3-27=0.foo}} {{28-32=}} {{34-35=other}}
+  unavailableInstanceSecond(a: 0, b: 1) // expected-error{{'unavailableInstanceSecond(a:b:)' has been renamed to 'Int.foo(other:self:)'}} {{3-28=1.foo}} {{29-30=other}} {{33-39=}}
+  unavailableInstanceSecondOfThree(a: 0, b: 1, c: 2) // expected-error{{'unavailableInstanceSecondOfThree(a:b:c:)' has been renamed to 'Int.foo(_:self:c:)'}} {{3-35=1.foo}} {{36-39=}} {{40-46=}}
+
+  unavailableInstance(a: 0 + 0) // expected-error{{'unavailableInstance(a:)' has been renamed to 'Int.foo(self:)'}} {{3-22=(0 + 0).foo}} {{23-31=}}
+}
+
+@available(*, unavailable, renamed: "Int.shinyLabeledArguments(self:)")
+func unavailableInstanceTooFew(a: Int, b: Int) {} // expected-note {{here}}
+@available(*, unavailable, renamed: "Int.shinyLabeledArguments(self:)")
+func unavailableInstanceTooFewUnnamed(_ a: Int, _ b: Int) {} // expected-note {{here}}
+@available(*, unavailable, renamed: "Int.shinyLabeledArguments(self:b:)")
+func unavailableInstanceTooMany(a: Int) {} // expected-note {{here}}
+@available(*, unavailable, renamed: "Int.shinyLabeledArguments(self:b:)")
+func unavailableInstanceTooManyUnnamed(_ a: Int) {} // expected-note {{here}}
+@available(*, unavailable, renamed: "Int.shinyLabeledArguments(self:)")
+func unavailableInstanceNoArgsTooMany() {} // expected-note {{here}}
+
+func testRenameInstanceArgMismatch() {
+  unavailableInstanceTooFew(a: 0, b: 1) // expected-error{{'unavailableInstanceTooFew(a:b:)' has been renamed to 'Int.shinyLabeledArguments(self:)'}} {{none}}
+  unavailableInstanceTooFewUnnamed(0, 1) // expected-error{{'unavailableInstanceTooFewUnnamed' has been renamed to 'Int.shinyLabeledArguments(self:)'}} {{none}}
+  unavailableInstanceTooMany(a: 0) // expected-error{{'unavailableInstanceTooMany(a:)' has been renamed to 'Int.shinyLabeledArguments(self:b:)'}} {{none}}
+  unavailableInstanceTooManyUnnamed(0) // expected-error{{'unavailableInstanceTooManyUnnamed' has been renamed to 'Int.shinyLabeledArguments(self:b:)'}} {{none}}
+  unavailableInstanceNoArgsTooMany() // expected-error{{'unavailableInstanceNoArgsTooMany()' has been renamed to 'Int.shinyLabeledArguments(self:)'}} {{none}}
+}