Merge pull request #3918 from jckarter/printasobjc-crash

PrintAsObjC: Handle new upper bounds of Array/Dictionary/Set correctly.

Author: shahmishal

lib/PrintAsObjC/PrintAsObjC.cpp

@@ -15,6 +15,7 @@
 #include "swift/AST/AST.h"
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/ForeignErrorConvention.h"
+#include "swift/AST/NameLookup.h"
 #include "swift/AST/PrettyStackTrace.h"
 #include "swift/AST/TypeVisitor.h"
 #include "swift/AST/Comment.h"
@@ -37,16 +38,24 @@
 
 using namespace swift;
 
-static bool isNSObject(ASTContext &ctx, Type type) {
+static bool isNSObjectOrAnyHashable(ASTContext &ctx, Type type) {
   if (auto classDecl = type->getClassOrBoundGenericClass()) {
     return classDecl->getName()
              == ctx.getSwiftId(KnownFoundationEntity::NSObject) &&
            classDecl->getModuleContext()->getName() == ctx.Id_ObjectiveC;
   }
+  if (auto nomDecl = type->getAnyNominal()) {
+    return nomDecl->getName() == ctx.getIdentifier("AnyHashable") &&
+      nomDecl->getModuleContext() == ctx.getStdlibModule();
+  }
 
   return false;
 }
 
+static bool isAnyObjectOrAny(Type type) {
+  return type->isAnyObject() || type->isAny();
+}
+
 /// Returns true if \p name matches a keyword in any Clang language mode.
 static bool isClangKeyword(Identifier name) {
   static const llvm::StringSet<> keywords = []{
@@ -125,6 +134,8 @@ class ObjCPrinter : private DeclVisitor<ObjCPrinter>,
   Accessibility minRequiredAccess;
   bool protocolMembersOptional = false;
 
+  Optional<Type> NSCopyingType;
+  
   friend ASTVisitor<ObjCPrinter>;
   friend TypeVisitor<ObjCPrinter>;
 
@@ -859,6 +870,8 @@ class ObjCPrinter : private DeclVisitor<ObjCPrinter>,
     auto &ctx = swiftNominal->getASTContext();
     assert(objcClass);
 
+    Type rewrittenArgsBuf[2];
+
     // Detect when the type arguments correspond to the unspecialized
     // type, and clear them out. There is some type-specific hackery
     // here for:
@@ -867,13 +880,38 @@ class ObjCPrinter : private DeclVisitor<ObjCPrinter>,
     //   NSDictionary<NSObject *, id> --> NSDictionary
     //   NSSet<id> --> NSSet
     if (!typeArgs.empty() &&
-        (!hasGenericObjCType(objcClass) ||
-         (swiftNominal == ctx.getArrayDecl() && typeArgs[0]->isAnyObject()) ||
-         (swiftNominal == ctx.getDictionaryDecl() &&
-          isNSObject(ctx, typeArgs[0]) && typeArgs[1]->isAnyObject()) ||
-         (swiftNominal == ctx.getSetDecl() && isNSObject(ctx, typeArgs[0])))) {
+        (!hasGenericObjCType(objcClass)
+         || (swiftNominal == ctx.getArrayDecl() &&
+             isAnyObjectOrAny(typeArgs[0]))
+         || (swiftNominal == ctx.getDictionaryDecl() &&
+             isNSObjectOrAnyHashable(ctx, typeArgs[0]) &&
+             isAnyObjectOrAny(typeArgs[1]))
+         || (swiftNominal == ctx.getSetDecl() &&
+             isNSObjectOrAnyHashable(ctx, typeArgs[0])))) {
       typeArgs = {};
     }
+    
+    // Use the proper upper id<NSCopying> bound for Dictionaries with
+    // upper-bounded keys.
+    else if (swiftNominal == ctx.getDictionaryDecl() &&
+             isNSObjectOrAnyHashable(ctx, typeArgs[0])) {
+      if (Module *M = ctx.getLoadedModule(ctx.Id_Foundation)) {
+        if (!NSCopyingType) {
+          UnqualifiedLookup lookup(ctx.getIdentifier("NSCopying"), M, nullptr);
+          auto type = lookup.getSingleTypeResult();
+          if (type && isa<ProtocolDecl>(type)) {
+            NSCopyingType = type->getDeclaredType();
+          } else {
+            NSCopyingType = Type();
+          }
+        }
+        if (*NSCopyingType) {
+          rewrittenArgsBuf[0] = *NSCopyingType;
+          rewrittenArgsBuf[1] = typeArgs[1];
+          typeArgs = rewrittenArgsBuf;
+        }
+      }
+    }
 
     // Print the class type.
     SmallString<32> objcNameScratch;
@@ -1119,12 +1157,17 @@ class ObjCPrinter : private DeclVisitor<ObjCPrinter>,
     // Use the type as bridged to Objective-C unless the element type is itself
     // an imported type or a collection.
     const StructDecl *SD = ty->getStructOrBoundGenericStruct();
-    if (SD != ctx.getArrayDecl() &&
+    if (ty->isAny()) {
+      ty = ctx.getProtocol(KnownProtocolKind::AnyObject)
+        ->getDeclaredType();
+    } else if (SD != ctx.getArrayDecl() &&
         SD != ctx.getDictionaryDecl() &&
         SD != ctx.getSetDecl() &&
         !isSwiftNewtype(SD)) {
       ty = *ctx.getBridgedToObjC(&M, ty, /*resolver*/nullptr);
     }
+    
+    assert(ty && "unknown bridged type");
 
     print(ty, None);
   }

test/Inputs/clang-importer-sdk/swift-modules/Foundation.swift

@@ -45,6 +45,24 @@ internal func _convertNSSetToSet<T : Hashable>(_ s: NSSet?) -> Set<T> {
   return Set<T>()
 }
 
+extension AnyHashable : _ObjectiveCBridgeable {
+  public func _bridgeToObjectiveC() -> NSObject {
+    return NSObject()
+  }
+  public static func _forceBridgeFromObjectiveC(_ x: NSObject,
+                                                result: inout AnyHashable?) {
+  }
+  public static func _conditionallyBridgeFromObjectiveC(
+    _ x: NSObject,
+    result: inout AnyHashable?
+  ) -> Bool {
+    return true
+  }
+  public static func _unconditionallyBridgeFromObjectiveC(_ x: NSObject?) -> AnyHashable {
+    return AnyHashable("")
+ }
+}
+
 extension String : _ObjectiveCBridgeable {
   public func _bridgeToObjectiveC() -> NSString {
     return NSString()

test/PrintAsObjC/any_as_id.swift

@@ -16,7 +16,6 @@
 // RUN: FileCheck %s < %t/any_as_id.h
 
 // RUN: %check-in-clang %t/any_as_id.h
-// RUN: %check-in-clang -fno-modules -Qunused-arguments %t/any_as_id.h
 
 import Foundation
 
@@ -25,33 +24,51 @@ import Foundation
 // CHECK-NEXT:  @interface AnyAsIdTest : NSObject
 class AnyAsIdTest : NSObject {
 
-// CHECK-NEXT:  - (void)takesId:(id _Nonnull)x;
-	func takesId(_ x: Any) {}
+// CHECK-NEXT:  - (NSArray * _Nonnull)arrayOfAny:(NSArray * _Nonnull)x;
+  func arrayOfAny(_ x: [Any]) -> [Any] { return x }
+// CHECK-NEXT:  - (NSArray * _Nullable)arrayOfAnyPerhaps:(NSArray * _Nonnull)x;
+  func arrayOfAnyPerhaps(_ x: [Any]) -> [Any]? { return x }
+
+// CHECK-NEXT:  - (NSDictionary * _Nonnull)dictionaryOfAny:(NSDictionary * _Nonnull)x;
+  func dictionaryOfAny(_ x: [AnyHashable: Any]) -> [AnyHashable: Any] { return x }
+// CHECK-NEXT:  - (void)dictionaryOfAnyKeys:(NSDictionary<id <NSCopying>, NSString *> * _Nonnull)x;
+  func dictionaryOfAnyKeys(_ x: [AnyHashable: String]) {}
+// CHECK-NEXT:  - (NSDictionary * _Nullable)dictionaryOfAnyMayhap:(NSDictionary * _Nonnull)x;
+  func dictionaryOfAnyMayhap(_ x: [AnyHashable: Any]) -> [AnyHashable: Any]? { return x }
+// CHECK-NEXT:  - (void)dictionaryOfAnyValues:(NSDictionary<NSString *, id> * _Nonnull)x;
+  func dictionaryOfAnyValues(_ x: [String: Any]) {}
 
 // CHECK-NEXT:  - (id _Nonnull)getAny;
   func getAny() -> Any { return 1 as Any }
+// CHECK-NEXT: - (id _Nullable)getAnyConstructively;
+  func getAnyConstructively() -> Any? { return Optional<Any>(1 as Any) }
+// CHECK-NEXT: - (id _Nullable)getAnyMaybe;
+  func getAnyMaybe() -> Any? { return nil }
+// CHECK-NEXT: - (id _Nullable)getAnyProbably;
+  func getAnyProbably() -> Any? { return 1 as Any }
 
 // CHECK-NEXT:  - (id _Nonnull)passThroughAny:(id _Nonnull)x;
   func passThroughAny(_ x: Any) -> Any { return x }
+// CHECK-NEXT: - (id _Nullable)passThroughAnyMaybe:(id _Nullable)x;
+  func passThroughAnyMaybe(_ x: Any?) -> Any? { return x }
+
+// CHECK-NEXT: - (void)setOfAny:(NSSet * _Nonnull)x;
+  func setOfAny(_ x: Set<AnyHashable>) {}
+
+// CHECK-NEXT:  - (void)takesId:(id _Nonnull)x;
+  func takesId(_ x: Any) {}
 
 // CHECK-NEXT: - (id _Nonnull)unwrapAny:(id _Nullable)x;
   func unwrapAny(_ x : Any?) -> Any { return x! }
 
-// CHECK-NEXT: - (id _Nullable)getAnyMaybe;
-  func getAnyMaybe() -> Any? { return nil }
-// CHECK-NEXT: - (id _Nullable)getAnyProbably;
-  func getAnyProbably() -> Any? { return 1 as Any }
-// CHECK-NEXT: - (id _Nullable)passThroughAnyMaybe:(id _Nullable)x;
-  func passThroughAnyMaybe(_ x: Any?) -> Any? { return x }
-// CHECK-NEXT: - (id _Nullable)getAnyConstructively;
-  func getAnyConstructively() -> Any? { return Optional<Any>(1 as Any) }
 // CHECK-NEXT: - (id _Nullable)wrapAny:(id _Nonnull)x;
   func wrapAny(_ x : Any) -> Any? { return x }
 
 // CHECK-NEXT:  - (nonnull instancetype)init OBJC_DESIGNATED_INITIALIZER;
-	/* implicit inherited init() */
+  /* implicit inherited init() */
+
 }
 // CHECK-NEXT:  @end
 
-
+extension NSArray { func forceToExist() {} }