Merge #2457 "Fix @objc checking for optional value types"

We previously treated 'NSFoo?' as ObjC-compatible simply because
'NSFoo' was an imported type or was marked '@objc'.

Author: jrose-apple

include/swift/AST/ASTContext.h

@@ -522,7 +522,7 @@ class ASTContext {
   ForeignRepresentationInfo
   getForeignRepresentationInfo(NominalTypeDecl *nominal,
                                ForeignLanguage language,
-                               DeclContext *dc);
+                               const DeclContext *dc);
 
   /// Add a declaration to a list of declarations that need to be emitted
   /// as part of the current module or source file, but are otherwise not

include/swift/AST/ProtocolConformance.h

@@ -254,7 +254,7 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance {
 
   /// Determine whether this protocol conformance is visible from the
   /// given declaration context.
-  bool isVisibleFrom(DeclContext *dc) const;
+  bool isVisibleFrom(const DeclContext *dc) const;
 
   /// Determine whether the witness for the given requirement
   /// is either the default definition or was otherwise deduced.

include/swift/AST/Types.h

@@ -712,22 +712,22 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// Determine whether the given type is representable in the given
   /// foreign language.
   std::pair<ForeignRepresentableKind, ProtocolConformance *>
-  getForeignRepresentableIn(ForeignLanguage language, DeclContext *dc);
+  getForeignRepresentableIn(ForeignLanguage language, const DeclContext *dc);
 
   /// Determines whether the given Swift type is representable within
   /// the given foreign language.
   ///
   /// A given Swift type is representable in the given foreign
   /// language if the Swift type can be used from source code written
   /// in that language.
-  bool isRepresentableIn(ForeignLanguage language, DeclContext *dc);
+  bool isRepresentableIn(ForeignLanguage language, const DeclContext *dc);
 
   /// Determines whether the type is trivially representable within
   /// the foreign language, meaning that it is both representable in
   /// that language and that the runtime representations are
   /// equivalent.
   bool isTriviallyRepresentableIn(ForeignLanguage language,
-                                  DeclContext *dc);
+                                  const DeclContext *dc);
 
   /// \brief Given that this is a nominal type or bound generic nominal
   /// type, return its parent type; this will be a null type if the type

lib/AST/ASTContext.cpp

@@ -3795,7 +3795,7 @@ static NominalTypeDecl *findUnderlyingTypeInModule(ASTContext &ctx,
 ForeignRepresentationInfo
 ASTContext::getForeignRepresentationInfo(NominalTypeDecl *nominal,
                                          ForeignLanguage language,
-                                         DeclContext *dc) {
+                                         const DeclContext *dc) {
   if (Impl.ForeignRepresentableCache.empty()) {
     // Local function to add a type with the given name and module as
     // trivially-representable.

lib/AST/ProtocolConformance.cpp

@@ -404,7 +404,7 @@ ProtocolConformance::getRootNormalConformance() const {
   return cast<NormalProtocolConformance>(C);
 }
 
-bool ProtocolConformance::isVisibleFrom(DeclContext *dc) const {
+bool ProtocolConformance::isVisibleFrom(const DeclContext *dc) const {
   // FIXME: Implement me!
   return true;
 }

lib/AST/Type.cpp

@@ -1930,8 +1930,8 @@ bool TypeBase::isPotentiallyBridgedValueType() {
 }
 
 /// Determine whether this is a representable Objective-C object type.
-static ForeignRepresentableKind getObjCObjectRepresentable(Type type,
-                                                           DeclContext *dc) {
+static ForeignRepresentableKind
+getObjCObjectRepresentable(Type type, const DeclContext *dc) {
   // @objc metatypes are representable when their instance type is.
   if (auto metatype = type->getAs<AnyMetatypeType>()) {
     // If the instance type is not representable, the metatype is not
@@ -1986,7 +1986,8 @@ static ForeignRepresentableKind getObjCObjectRepresentable(Type type,
 /// to be reflected in PrintAsObjC, so that the Swift type will be
 /// properly printed for (Objective-)C and in SIL's bridging logic.
 static std::pair<ForeignRepresentableKind, ProtocolConformance *>
-getForeignRepresentable(Type type, ForeignLanguage language, DeclContext *dc) {
+getForeignRepresentable(Type type, ForeignLanguage language,
+                        const DeclContext *dc) {
   // Look through one level of optional type, but remember that we did.
   bool wasOptional = false;
   if (auto valueType = type->getAnyOptionalObjectType()) {
@@ -2089,10 +2090,6 @@ getForeignRepresentable(Type type, ForeignLanguage language, DeclContext *dc) {
 
   ASTContext &ctx = nominal->getASTContext();
 
-  // If the type is @objc, it is trivially representable in Objective-C.
-  if (nominal->isObjC() && language == ForeignLanguage::ObjectiveC)
-    return { ForeignRepresentableKind::Trivial, nullptr };
-
   // Unmanaged<T> can be trivially represented in Objective-C if T
   // is trivially represented in Objective-C.
   if (language == ForeignLanguage::ObjectiveC &&
@@ -2112,14 +2109,17 @@ getForeignRepresentable(Type type, ForeignLanguage language, DeclContext *dc) {
 
   // If the type was imported from Clang, check whether it is
   // representable in the requested language.
-  if (nominal->hasClangNode()) {
+  if (nominal->hasClangNode() || nominal->isObjC()) {
     switch (language) {
     case ForeignLanguage::C:
       // Imported structs and enums are trivially representable in C.
       // FIXME: This is not entirely true; we need to check that
       // all of the exposed parts are representable in C.
-      if (isa<StructDecl>(nominal) || isa<EnumDecl>(nominal))
+      if (isa<StructDecl>(nominal) || isa<EnumDecl>(nominal)) {
+        if (wasOptional)
+          break;
         return { ForeignRepresentableKind::Trivial, nullptr };
+      }
 
       // Imported classes and protocols are not.
       if (isa<ClassDecl>(nominal) || isa<ProtocolDecl>(nominal))
@@ -2128,7 +2128,10 @@ getForeignRepresentable(Type type, ForeignLanguage language, DeclContext *dc) {
       llvm_unreachable("Unhandled nominal type declaration");
 
     case ForeignLanguage::ObjectiveC:
-      // Anything Clang imported is trivially representable in Objective-C.
+      if (isa<StructDecl>(nominal) || isa<EnumDecl>(nominal))
+        if (wasOptional)
+          break;
+
       return { ForeignRepresentableKind::Trivial, nullptr };
     }
   }
@@ -2218,11 +2221,13 @@ getForeignRepresentable(Type type, ForeignLanguage language, DeclContext *dc) {
 }
 
 std::pair<ForeignRepresentableKind, ProtocolConformance *>
-TypeBase::getForeignRepresentableIn(ForeignLanguage language, DeclContext *dc) {
+TypeBase::getForeignRepresentableIn(ForeignLanguage language,
+                                    const DeclContext *dc) {
   return getForeignRepresentable(Type(this), language, dc);
 }
 
-bool TypeBase::isRepresentableIn(ForeignLanguage language, DeclContext *dc) {
+bool TypeBase::isRepresentableIn(ForeignLanguage language,
+                                 const DeclContext *dc) {
   switch (getForeignRepresentableIn(language, dc).first) {
   case ForeignRepresentableKind::None:
     return false;
@@ -2236,7 +2241,7 @@ bool TypeBase::isRepresentableIn(ForeignLanguage language, DeclContext *dc) {
 }
 
 bool TypeBase::isTriviallyRepresentableIn(ForeignLanguage language,
-                                          DeclContext *dc) {
+                                          const DeclContext *dc) {
   switch (getForeignRepresentableIn(language, dc).first) {
   case ForeignRepresentableKind::None:
   case ForeignRepresentableKind::Bridged:

lib/SILGen/SILGenExpr.cpp

@@ -2292,25 +2292,14 @@ RValue RValueEmitter::visitRebindSelfInConstructorExpr(
 static bool isNullableTypeInC(SILModule &M, Type ty) {
   ty = ty->getLValueOrInOutObjectType()->getReferenceStorageReferent();
 
+  // Functions, class instances, and @objc existentials are all nullable.
   if (ty->hasReferenceSemantics())
     return true;
-  
-  auto &C = ty->getASTContext();
-  auto nom = ty->getAnyNominal();
-  if (!nom)
-    return false;
 
-  if (nom == C.getUnsafePointerDecl()
-      || nom == C.getUnsafeMutablePointerDecl()
-      || nom == C.getAutoreleasingUnsafeMutablePointerDecl()
-      || nom == C.getOpaquePointerDecl())
-    return true;
-  
-  auto selectorTy = M.Types.getSelectorType();
-  if (selectorTy && ty->isEqual(selectorTy))
-    return true;
-  
-  return false;
+  // Other types like UnsafePointer can also be nullable.
+  ty = OptionalType::get(ty);
+  return ty->isTriviallyRepresentableIn(ForeignLanguage::C,
+                                        M.getAssociatedContext());
 }
 
 /// Determine whether the given declaration returns a non-optional object that

test/attr/attr_objc.swift

@@ -1106,6 +1106,7 @@ class infer_instanceVar1 {
   var var_Optional12: OpaquePointer?
   var var_Optional13: UnsafeMutablePointer<Int>?
   var var_Optional14: UnsafeMutablePointer<Class_ObjC1>?
+  var var_Optional15: NSRange? // another bridged struct
 
 // CHECK-LABEL: @objc var var_Optional1: Class_ObjC1?
 // CHECK-LABEL: @objc var var_Optional2: Protocol_ObjC1?
@@ -1121,6 +1122,7 @@ class infer_instanceVar1 {
 // CHECK-LABEL: @objc var var_Optional12: OpaquePointer?
 // CHECK-LABEL: @objc var var_Optional13: UnsafeMutablePointer<Int>?
 // CHECK-LABEL: @objc var var_Optional14: UnsafeMutablePointer<Class_ObjC1>?
+// CHECK-LABEL: @objc var var_Optional15: NSRange?
 
 
   var var_ImplicitlyUnwrappedOptional1: Class_ObjC1!
@@ -1159,6 +1161,7 @@ class infer_instanceVar1 {
   var var_Optional_fail14: CBool?
   var var_Optional_fail20: AnyObject??
   var var_Optional_fail21: AnyObject.Type??
+  var var_Optional_fail22: NSComparisonResult? // a non-bridged imported value type
 // CHECK-NOT: @objc{{.*}}Optional_fail
 
   // CHECK-LABEL: @objc var var_CFunctionPointer_1: @convention(c) () -> ()