Finish off the log part of _swift_checkClassAndWarnForKeyedArchiving. (#10418)

Logs a warning the first time a problematic class is archived or
unarchived. We expect people to actually fix these issues, so the
performance of the warning isn't too important.

Sample output:

  [timestamp] Attempting to archive Swift class '_Test.Outer.ArchivedThenUnarchived', which does not have a stable runtime name.
  [timestamp] Use the 'objc' attribute to ensure that the runtime name will not change: "@objc(_TtCC5_Test5Outer22ArchivedThenUnarchived)"
  [timestamp] If there are no existing archives containing this class, you can choose a unique, prefixed name instead: "@objc(ABCArchivedThenUnarchived)"

Finishes rdar://problem/32414508

Author: jrose-apple

stdlib/public/SDK/Foundation/CheckClass.mm

@@ -2,6 +2,7 @@
 
 #include <objc/runtime.h>
 
+#include "swift/Runtime/HeapObject.h"
 #include "swift/Runtime/Metadata.h"
 
 @interface NSKeyedUnarchiver (SwiftAdditions)
@@ -10,9 +11,116 @@ + (int)_swift_checkClassAndWarnForKeyedArchiving:(Class)cls
      NS_SWIFT_NAME(_swift_checkClassAndWarnForKeyedArchiving(_:operation:));
 @end
 
+static bool isASCIIIdentifierChar(char c) {
+  if (c >= 'a' && c <= 'z') return true;
+  if (c >= 'A' && c <= 'Z') return true;
+  if (c >= '0' && c <= '9') return true;
+  if (c == '_') return true;
+  if (c == '$') return true;
+  return false;
+}
+
+static void logIfFirstOccurrence(Class objcClass, void (^log)(void)) {
+  static auto queue = dispatch_queue_create(
+      "SwiftFoundation._checkClassAndWarnForKeyedArchivingQueue",
+      DISPATCH_QUEUE_SERIAL);
+  static NSHashTable *seenClasses = nil;
+
+  dispatch_sync(queue, ^{
+    // Will be NO when seenClasses is still nil.
+    if ([seenClasses containsObject:objcClass])
+      return;
+
+    if (!seenClasses) {
+      NSPointerFunctionsOptions options = 0;
+      options |= NSPointerFunctionsOpaqueMemory;
+      options |= NSPointerFunctionsObjectPointerPersonality;
+      seenClasses = [[NSHashTable alloc] initWithOptions:options capacity:16];
+    }
+    [seenClasses addObject:objcClass];
+
+    // Synchronize logging so that multiple lines aren't interleaved.
+    log();
+  });
+}
+
+namespace {
+  class StringRefLite {
+    StringRefLite(const char *data, size_t len) : data(data), length(len) {}
+  public:
+    const char *data;
+    size_t length;
+
+    StringRefLite() : data(nullptr), length(0) {}
+
+    template <size_t N>
+    StringRefLite(const char (&staticStr)[N]) : data(staticStr), length(N) {}
+
+    StringRefLite(swift::TwoWordPair<const char *, uintptr_t> pair)
+        : data(pair.first), length(pair.second) {}
+
+    NS_RETURNS_RETAINED
+    NSString *newNSStringNoCopy() const {
+      return [[NSString alloc] initWithBytesNoCopy:const_cast<char *>(data)
+                                            length:length
+                                          encoding:NSUTF8StringEncoding
+                                      freeWhenDone:NO];
+    }
+
+    const char &operator[](size_t offset) const {
+      assert(offset < length);
+      return data[offset];
+    }
+
+    StringRefLite slice(size_t from, size_t to) const {
+      assert(from <= to);
+      assert(to <= length);
+      return {data + from, to - from};
+    }
+
+    const char *begin() const {
+      return data;
+    }
+    const char *end() const {
+      return data + length;
+    }
+  };
+}
+
+/// Assume that a non-generic demangled class name always ends in ".MyClass"
+/// or ".(MyClass plus extra info)".
+static StringRefLite findBaseName(StringRefLite demangledName) {
+  size_t end = demangledName.length;
+  size_t parenCount = 0;
+  for (size_t i = end; i != 0; --i) {
+    switch (demangledName[i - 1]) {
+    case '.':
+      if (parenCount == 0) {
+        if (i != end && demangledName[i] == '(')
+          ++i;
+        return demangledName.slice(i, end);
+      }
+      break;
+    case ')':
+      parenCount += 1;
+      break;
+    case '(':
+      if (parenCount > 0)
+        parenCount -= 1;
+      break;
+    case ' ':
+      end = i - 1;
+      break;
+    default:
+      break;
+    }
+  }
+  return {};
+}
+
 @implementation NSKeyedUnarchiver (SwiftAdditions)
 
-/// Checks if class \p cls is good for archiving.
+/// Checks if class \p objcClass is good for archiving.
 ///
 /// If not, a runtime warning is printed.
 ///
@@ -25,20 +133,21 @@ @implementation NSKeyedUnarchiver (SwiftAdditions)
 /// 2:       a Swift non-generic class where adding @objc is valid
 /// Future versions of this API will return nonzero values for additional cases
 /// that mean the class shouldn't be archived.
-+ (int)_swift_checkClassAndWarnForKeyedArchiving:(Class)cls
++ (int)_swift_checkClassAndWarnForKeyedArchiving:(Class)objcClass
                                        operation:(int)operation {
-  const swift::ClassMetadata *theClass = (swift::ClassMetadata *)cls;
+  using namespace swift;
+  const ClassMetadata *theClass = (ClassMetadata *)objcClass;
 
   // Is it a (real) swift class?
   if (!theClass->isTypeMetadata() || theClass->isArtificialSubclass())
     return 0;
 
   // Does the class already have a custom name?
-  if (theClass->getFlags() & swift::ClassFlags::HasCustomObjCName)
+  if (theClass->getFlags() & ClassFlags::HasCustomObjCName)
     return 0;
 
   // Is it a mangled name?
-  const char *className = class_getName(cls);
+  const char *className = class_getName(objcClass);
   if (!(className[0] == '_' && className[1] == 'T'))
     return 0;
   // Is it a name in the form <module>.<class>? Note: the module name could
@@ -48,13 +157,74 @@ + (int)_swift_checkClassAndWarnForKeyedArchiving:(Class)cls
 
   // Is it a generic class?
   if (theClass->getDescription()->GenericParams.isGeneric()) {
-    // TODO: print a warning
+    logIfFirstOccurrence(objcClass, ^{
+      // Use actual NSStrings to force UTF-8.
+      StringRefLite demangledName = swift_getTypeName(theClass,
+                                                      /*qualified*/true);
+      NSString *demangledString = demangledName.newNSStringNoCopy();
+      NSString *mangledString = NSStringFromClass(objcClass);
+      switch (operation) {
+      case 1:
+        NSLog(@"Attempting to unarchive generic Swift class '%@' with mangled "
+               "runtime name '%@'. Runtime names for generic classes are "
+               "unstable and may change in the future, leading to "
+               "non-decodable data.", demangledString, mangledString);
+        break;
+      default:
+        NSLog(@"Attempting to archive generic Swift class '%@' with mangled "
+               "runtime name '%@'. Runtime names for generic classes are "
+               "unstable and may change in the future, leading to "
+               "non-decodable data.", demangledString, mangledString);
+        break;
+      }
+      NSLog(@"To avoid this failure, create a concrete subclass and register "
+             "it with NSKeyedUnarchiver.setClass(_:forClassName:) instead, "
+             "using the name \"%@\".", mangledString);
+      NSLog(@"If you need to produce archives compatible with older versions "
+             "of your program, use NSKeyedArchiver.setClassName(_:for:) "
+             "as well.");
+      [demangledString release];
+    });
     return 1;
   }
 
   // It's a swift class with a (compiler generated) mangled name, which should
   // be written into an NSArchive.
-  // TODO: print a warning
+  logIfFirstOccurrence(objcClass, ^{
+    // Use actual NSStrings to force UTF-8.
+    StringRefLite demangledName = swift_getTypeName(theClass,/*qualified*/true);
+    NSString *demangledString = demangledName.newNSStringNoCopy();
+    NSString *mangledString = NSStringFromClass(objcClass);
+    switch (operation) {
+    case 1:
+      NSLog(@"Attempting to unarchive Swift class '%@' with mangled runtime "
+             "name '%@'. The runtime name for this class is unstable and may "
+             "change in the future, leading to non-decodable data.",
+             demangledString, mangledString);
+      break;
+    default:
+      NSLog(@"Attempting to archive Swift class '%@' with mangled runtime "
+             "name '%@'. The runtime name for this class is unstable and may "
+             "change in the future, leading to non-decodable data.",
+             demangledString, mangledString);
+      break;
+    }
+    [demangledString release];
+    NSLog(@"You can use the 'objc' attribute to ensure that the name will not "
+           "change: \"@objc(%@)\"", mangledString);
+
+    StringRefLite baseName = findBaseName(demangledName);
+    // Offer a more generic message if the base name we found doesn't look like
+    // an ASCII identifier. This avoids printing names like "ABCモデル".
+    if (baseName.length == 0 ||
+        !std::all_of(baseName.begin(), baseName.end(), isASCIIIdentifierChar)) {
+      baseName = "MyModel";
+    }
+
+    NSLog(@"If there are no existing archives containing this class, you "
+           "should choose a unique, prefixed name instead: "
+           "\"@objc(ABC%1$.*2$s)\"", baseName.data, (int)baseName.length);
+  });
   return 2;
 }
 @end