[ClangImporter] Import Swift 3 versions of top-level decls in Swift 4.

...and Swift 4 versions in Swift 3, and Swift 2 and "raw" versions in
both. This allows the compiler to produce sensible errors and fix-its
when someone uses the "wrong" name for an API. The diagnostics
certainly have room to improve, but at least the essentials are there.

Note that this commit only addresses /top-level/ decls, i.e. those
found by lookup into a module. We're still limited to producing all
members of a nominal type up front, so that'll require a slightly
different approach.

Part of rdar://problem/29170671

Author: jrose-apple

lib/ClangImporter/ClangImporter.cpp

@@ -2738,17 +2738,51 @@ void ClangImporter::Implementation::lookupValue(
       }
     }
 
-    // If we have a declaration and nothing matched so far, try the Swift 2
-    // name.
+    // If we have a declaration and nothing matched so far, try the names used
+    // in other versions of Swift.
     if (!anyMatching) {
       if (auto clangDecl = entry.dyn_cast<clang::NamedDecl *>()) {
-        if (auto swift2Decl = cast_or_null<ValueDecl>(importDeclReal(
-                clangDecl->getMostRecentDecl(), ImportNameVersion::Swift2))) {
-          if (swift2Decl->getFullName().matchesRef(name) &&
-              swift2Decl->getDeclContext()->isModuleScopeContext()) {
-            consumer.foundDecl(swift2Decl,
+        const clang::NamedDecl *recentClangDecl =
+            clangDecl->getMostRecentDecl();
+        auto tryImport = [&](ImportNameVersion nameVersion) -> bool {
+          // Check to see if the name and context match what we expect.
+          ImportedName newName = importFullName(recentClangDecl, nameVersion);
+          if (!newName.getDeclName().matchesRef(name))
+            return false;
+
+          const clang::DeclContext *clangDC =
+              newName.getEffectiveContext().getAsDeclContext();
+          if (!clangDC || !clangDC->isFileContext())
+            return false;
+
+          // Then try to import the decl under the alternate name.
+          auto alternateNamedDecl =
+              cast_or_null<ValueDecl>(importDeclReal(recentClangDecl,
+                                                     nameVersion));
+          if (!alternateNamedDecl)
+            return false;
+          assert(alternateNamedDecl->getFullName().matchesRef(name) &&
+                 "importFullName behaved differently from importDecl");
+          if (alternateNamedDecl->getDeclContext()->isModuleScopeContext()) {
+            consumer.foundDecl(alternateNamedDecl,
                                DeclVisibilityKind::VisibleAtTopLevel);
+            return true;
           }
+          return false;
+        };
+
+        // Try importing previous versions of the decl first...
+        ImportNameVersion nameVersion = CurrentVersion;
+        while (!anyMatching && nameVersion != ImportNameVersion::Raw) {
+          --nameVersion;
+          anyMatching = tryImport(nameVersion);
+        }
+        // ...then move on to newer versions if none of the old versions
+        // matched.
+        nameVersion = CurrentVersion;
+        while (!anyMatching && nameVersion != ImportNameVersion::LAST_VERSION) {
+          ++nameVersion;
+          anyMatching = tryImport(nameVersion);
         }
       }
     }

lib/ClangImporter/ImportDecl.cpp

@@ -2009,10 +2009,34 @@ namespace {
             /*fullyQualified=*/correctSwiftName.importAsMember(), os);
       }
 
-      auto attr = AvailableAttr::createPlatformAgnostic(
-                    ctx, StringRef(), ctx.AllocateCopy(renamed.str()),
-                    PlatformAgnosticAvailabilityKind::SwiftVersionSpecific,
-                    clang::VersionTuple(3));
+      unsigned majorVersion = majorVersionNumberForNameVersion(getVersion());
+      DeclAttribute *attr;
+      if (isActiveSwiftVersion() || getVersion() == ImportNameVersion::Raw) {
+        // "Raw" is the Objective-C name, which was never available in Swift.
+        // Variants within the active version are usually declarations that
+        // have been superseded, like the accessors of a property.
+        attr = AvailableAttr::createPlatformAgnostic(
+            ctx, /*Message*/StringRef(), ctx.AllocateCopy(renamed.str()),
+            PlatformAgnosticAvailabilityKind::UnavailableInSwift);
+      } else if (getVersion() < getActiveSwiftVersion()) {
+        // A Swift 2 name, for example, was obsoleted in Swift 3.
+        attr = AvailableAttr::createPlatformAgnostic(
+            ctx, /*Message*/StringRef(), ctx.AllocateCopy(renamed.str()),
+            PlatformAgnosticAvailabilityKind::SwiftVersionSpecific,
+            clang::VersionTuple(majorVersion + 1));
+      } else {
+        // Future names are introduced in their future version.
+        assert(getVersion() > getActiveSwiftVersion());
+        attr = new (ctx) AvailableAttr(
+            SourceLoc(), SourceRange(), PlatformKind::none,
+            /*Message*/StringRef(), ctx.AllocateCopy(renamed.str()),
+            /*Introduced*/clang::VersionTuple(majorVersion), SourceRange(),
+            /*Deprecated*/clang::VersionTuple(), SourceRange(),
+            /*Obsoleted*/clang::VersionTuple(), SourceRange(),
+            PlatformAgnosticAvailabilityKind::SwiftVersionSpecific,
+            /*Implicit*/true);
+      }
+
       decl->getAttrs().add(attr);
       decl->setImplicit();
     }
@@ -3485,31 +3509,12 @@ namespace {
                             {decl->param_begin(), decl->param_size()},
                             decl->isVariadic(), redundant);
 
-      // Directly ask the NameImporter for the non-init variant of the Swift 2
-      // name.
-      auto rawName = Impl.importFullName(decl, ImportNameVersion::Raw);
-      if (!rawName)
-        return result;
-
-      auto rawDecl = importNonInitObjCMethodDecl(decl, dc, rawName, selector,
-                                                 forceClassMethod);
-      if (!rawDecl)
-        return result;
-
-      // Mark the raw imported class method "unavailable", with a useful error
-      // message.
-      llvm::SmallString<64> message;
-      llvm::raw_svector_ostream os(message);
-      os << "use object construction '" << decl->getClassInterface()->getName()
-         << "(";
-      for (auto arg : importedName.getDeclName().getArgumentNames()) {
-        os << arg << ":";
+      if (auto rawDecl = Impl.importDecl(decl, ImportNameVersion::Raw)) {
+        // We expect the raw decl to always be a method.
+        assert(isa<FuncDecl>(rawDecl));
+        Impl.addAlternateDecl(result, cast<ValueDecl>(rawDecl));
       }
-      os << ")'";
-      rawDecl->getAttrs().add(AvailableAttr::createPlatformAgnostic(
-          Impl.SwiftContext, Impl.SwiftContext.AllocateCopy(os.str())));
-      markAsVariant(rawDecl, importedName);
-      Impl.addAlternateDecl(result, cast<ValueDecl>(rawDecl));
+
       return result;
     }
 

lib/ClangImporter/ImportName.cpp

@@ -68,6 +68,20 @@ importer::nameVersionFromOptions(const LangOptions &langOpts) {
   }
 }
 
+unsigned importer::majorVersionNumberForNameVersion(ImportNameVersion version) {
+  switch (version) {
+  case ImportNameVersion::Raw:
+    return 0;
+  case ImportNameVersion::Swift2:
+    return 2;
+  case ImportNameVersion::Swift3:
+    return 3;
+  case ImportNameVersion::Swift4:
+    return 4;
+  }
+}
+
+
 /// Determine whether the given Clang selector matches the given
 /// selector pieces.
 static bool isNonNullarySelector(clang::Selector selector,
@@ -560,17 +574,48 @@ determineCtorInitializerKind(const clang::ObjCMethodDecl *method) {
   return None;
 }
 
+template <typename A>
+static bool matchesVersion(A *versionedAttr, ImportNameVersion version) {
+  clang::VersionTuple attrVersion = versionedAttr->getVersion();
+  if (attrVersion.empty())
+    return version == ImportNameVersion::LAST_VERSION;
+  return attrVersion.getMajor() == majorVersionNumberForNameVersion(version);
+}
+
 const clang::SwiftNameAttr *
 importer::findSwiftNameAttr(const clang::Decl *decl,
                             ImportNameVersion version) {
-  // Find the attribute.
+  if (version == ImportNameVersion::Raw)
+    return nullptr;
+
+  // Handle versioned API notes for Swift 3 and later. This is the common case.
+  if (version != ImportNameVersion::Swift2) {
+    for (auto *attr : decl->attrs()) {
+      if (auto *versionedAttr = dyn_cast<clang::SwiftVersionedAttr>(attr)) {
+        if (!matchesVersion(versionedAttr, version))
+          continue;
+        if (auto *added =
+              dyn_cast<clang::SwiftNameAttr>(versionedAttr->getAttrToAdd())) {
+          return added;
+        }
+      }
+
+      if (auto *removeAttr = dyn_cast<clang::SwiftVersionedRemovalAttr>(attr)) {
+        if (!matchesVersion(removeAttr, version))
+          continue;
+        if (removeAttr->getAttrKindToRemove() == clang::attr::SwiftName)
+          return nullptr;
+      }
+    }
+
+    return decl->getAttr<clang::SwiftNameAttr>();
+  }
+
+  // The remainder of this function emulates the limited form of swift_name
+  // supported in Swift 2.
   auto attr = decl->getAttr<clang::SwiftNameAttr>();
   if (!attr) return nullptr;
 
-  // If we're not emulating the Swift 2 behavior, return what we got.
-  if (version != ImportNameVersion::Swift2)
-    return attr;
-
   // API notes produce implicit attributes; ignore them because they weren't
   // used for naming in Swift 2.
   if (attr->isImplicit()) return nullptr;

lib/ClangImporter/ImportName.h

@@ -25,9 +25,6 @@
 #include "swift/AST/ForeignErrorConvention.h"
 #include "clang/Sema/Sema.h"
 
-// TODO: remove when we drop import name options
-#include "clang/AST/Decl.h"
-
 namespace swift {
 namespace importer {
 struct PlatformAvailability;
@@ -55,18 +52,36 @@ enum class ImportNameVersion : unsigned {
 
   /// Names as they appeared in Swift 4 family
   Swift4,
+
+  /// A placeholder for the latest version, to be used in loops and such.
+  LAST_VERSION = Swift4
 };
-enum { NumImportNameVersions = 4 };
 
 static inline void
 forEachImportNameVersion(llvm::function_ref<void(ImportNameVersion)> action) {
-  for (unsigned raw = 0; raw < NumImportNameVersions; ++raw)
+  auto limit = static_cast<unsigned>(ImportNameVersion::LAST_VERSION);
+  for (unsigned raw = 0; raw <= limit; ++raw)
     action(static_cast<ImportNameVersion>(raw));
 }
 
-/// Map a language version into an import name version
+static inline ImportNameVersion &operator++(ImportNameVersion &value) {
+  assert(value != ImportNameVersion::LAST_VERSION);
+  value = static_cast<ImportNameVersion>(static_cast<unsigned>(value) + 1);
+  return value;
+}
+
+static inline ImportNameVersion &operator--(ImportNameVersion &value) {
+  assert(value != ImportNameVersion::Raw);
+  value = static_cast<ImportNameVersion>(static_cast<unsigned>(value) - 1);
+  return value;
+}
+
+/// Map a language version into an import name version.
 ImportNameVersion nameVersionFromOptions(const LangOptions &langOpts);
 
+/// Map an import name version into a language version.
+unsigned majorVersionNumberForNameVersion(ImportNameVersion version);
+
 /// Describes a name that was imported from Clang.
 class ImportedName {
   friend class NameImporter;

lib/ClangImporter/SwiftLookupTable.cpp

@@ -1541,9 +1541,8 @@ void importer::addEntryToLookupTable(SwiftLookupTable &table,
   }
 
   // If we have a name to import as, add this entry to the table.
-  // FIXME: It doesn't actually matter which version we use here, but it should
-  // probably follow the ASTContext anyway.
-  ImportNameVersion currentVersion = ImportNameVersion::Swift3;
+  ImportNameVersion currentVersion =
+      nameVersionFromOptions(nameImporter.getLangOpts());
   if (auto importedName = nameImporter.importName(named, currentVersion)) {
     SmallPtrSet<DeclName, 8> distinctNames;
     distinctNames.insert(importedName.getDeclName());

test/APINotes/versioned.swift

@@ -9,3 +9,28 @@
 
 // CHECK-SWIFT-4: func accept(_ ptr: UnsafeMutablePointer<Double>)
 // CHECK-SWIFT-3: func acceptPointer(_ ptr: UnsafeMutablePointer<Double>?)
+
+// RUN: not %target-swift-frontend -typecheck -F %S/Inputs/custom-frameworks -swift-version 4 %s 2>&1 | %FileCheck -check-prefix=CHECK-DIAGS -check-prefix=CHECK-DIAGS-4 %s
+// RUN: not %target-swift-frontend -typecheck -F %S/Inputs/custom-frameworks -swift-version 3 %s 2>&1 | %FileCheck -check-prefix=CHECK-DIAGS -check-prefix=CHECK-DIAGS-3 %s
+
+import APINotesFrameworkTest
+
+func testRenamedTopLevel() {
+  var value = 0.0
+
+  // CHECK-DIAGS-4-NOT: versioned.swift:[[@LINE+1]]
+  accept(&value)
+  // CHECK-DIAGS-3: versioned.swift:[[@LINE-1]]:3: error: 'accept' has been renamed to 'acceptPointer(_:)'
+  // CHECK-DIAGS-3: note: 'accept' was introduced in Swift 4
+
+  // CHECK-DIAGS-4-NOT: versioned.swift:[[@LINE+1]]
+  acceptPointer(&value)
+  // CHECK-DIAGS-4: versioned.swift:[[@LINE-1]]:3: error: 'acceptPointer' has been renamed to 'accept(_:)'
+  // CHECK-DIAGS-4: note: 'acceptPointer' was obsoleted in Swift 4
+
+  acceptDoublePointer(&value)
+  // CHECK-DIAGS: versioned.swift:[[@LINE-1]]:3: error: 'acceptDoublePointer' has been renamed to
+  // CHECK-DIAGS-4: 'accept(_:)'
+  // CHECK-DIAGS-3: 'acceptPointer(_:)'
+  // CHECK-DIAGS: note: 'acceptDoublePointer' was obsoleted in Swift 3
+}

test/ClangImporter/Inputs/SwiftPrivateAttr.txt

@@ -9,8 +9,14 @@ class Foo : NSObject, __PrivProto {
   func __oneArg(_ arg: Int32)
   func __twoArgs(_ arg: Int32, other arg2: Int32)
   class func __withNoArgs() -> Self!
+  @available(*, unavailable, renamed: "init(__oneArg:)", message: "Not available in Swift")
+  class func __fooWithOneArg(_ arg: Int32) -> Self!
   convenience init!(__oneArg arg: Int32)
+  @available(*, unavailable, renamed: "init(__twoArgs:other:)", message: "Not available in Swift")
+  class func __fooWithTwoArgs(_ arg: Int32, other arg2: Int32) -> Self!
   convenience init!(__twoArgs arg: Int32, other arg2: Int32)
+  @available(*, unavailable, renamed: "init(__:)", message: "Not available in Swift")
+  class func __foo(_ arg: Int32) -> Self!
   convenience init!(__ arg: Int32)
   func objectForKeyedSubscript(_ index: Any!) -> Any!
   func __setObject(_ object: Any!, forKeyedSubscript index: Any!)

test/ClangImporter/attr-swift_private.swift

@@ -135,8 +135,8 @@ _ = 1 as __PrivInt
 
 #if !IRGEN
 func testRawNames() {
-  let _ = Foo.__fooWithOneArg(0) // expected-error {{'__fooWithOneArg' is unavailable: use object construction 'Foo(__oneArg:)'}}
-  let _ = Foo.__foo // expected-error{{'__foo' is unavailable: use object construction 'Foo(__:)'}}
+  let _ = Foo.__fooWithOneArg(0) // expected-error {{'__fooWithOneArg' has been replaced by 'init(__oneArg:)'}}
+  let _ = Foo.__foo // expected-error{{'__foo' has been replaced by 'init(__:)'}}
 }
 #endif
 

test/ClangImporter/objc_factory_method.swift

@@ -84,7 +84,7 @@ func testNonInstanceTypeFactoryMethod(_ s: String) {
 }
 
 func testUseOfFactoryMethod(_ queen: Bee) {
-  _ = Hive.hiveWithQueen(queen) // expected-error{{'hiveWithQueen' is unavailable: use object construction 'Hive(queen:)'}}
+  _ = Hive.hiveWithQueen(queen) // expected-error{{'hiveWithQueen' has been replaced by 'init(queen:)'}} {{11-25=}} {{26-26=queen: }}
 }
 
 func testNonsplittableFactoryMethod() {
@@ -97,18 +97,18 @@ func testFactoryMethodBlacklist() {
 
 func test17261609() {
   _ = NSDecimalNumber(mantissa:1, exponent:1, isNegative:true)
-  _ = NSDecimalNumber.decimalNumberWithMantissa(1, exponent:1, isNegative:true) // expected-error{{'decimalNumberWithMantissa(_:exponent:isNegative:)' is unavailable: use object construction 'NSDecimalNumber(mantissa:exponent:isNegative:)'}}
+  _ = NSDecimalNumber.decimalNumberWithMantissa(1, exponent:1, isNegative:true) // expected-error{{'decimalNumberWithMantissa(_:exponent:isNegative:)' has been replaced by 'init(mantissa:exponent:isNegative:)'}} {{22-48=}} {{49-49=mantissa: }}
 }
 
 func testURL() {
   let url = NSURL(string: "http://www.llvm.org")!
-  _ = NSURL.URLWithString("http://www.llvm.org") // expected-error{{'URLWithString' is unavailable: use object construction 'NSURL(string:)'}}
+  _ = NSURL.URLWithString("http://www.llvm.org") // expected-error{{'URLWithString' has been replaced by 'init(string:)'}} {{12-26=}} {{27-27=string: }}
 
   NSURLRequest(string: "http://www.llvm.org") // expected-warning{{unused}}
   NSURLRequest(url: url as URL) // expected-warning{{unused}}
 
-  _ = NSURLRequest.requestWithString("http://www.llvm.org") // expected-error{{'requestWithString' is unavailable: use object construction 'NSURLRequest(string:)'}}
-  _ = NSURLRequest.URLRequestWithURL(url as URL) // expected-error{{'URLRequestWithURL' is unavailable: use object construction 'NSURLRequest(url:)'}}
+  _ = NSURLRequest.requestWithString("http://www.llvm.org") // expected-error{{'requestWithString' has been replaced by 'init(string:)'}}
+  _ = NSURLRequest.URLRequestWithURL(url as URL) // expected-error{{'URLRequestWithURL' has been replaced by 'init(url:)'}}
 }
 
 // FIXME: Remove -verify-ignore-unknown.

test/ClangImporter/objc_implicit_with.swift

@@ -50,7 +50,7 @@ func testNonInstanceTypeFactoryMethod(_ s: String) {
 }
 
 func testUseOfFactoryMethod(_ queen: Bee) {
-  _ = Hive.hiveWithQueen(queen) // expected-error{{'hiveWithQueen' is unavailable: use object construction 'Hive(queen:)'}}
+  _ = Hive.hiveWithQueen(queen) // expected-error{{'hiveWithQueen' has been replaced by 'init(queen:)'}} {{11-25=}} {{26-26=queen: }}
 }
 
 func testNonsplittableFactoryMethod() {