[IRGen] Use a more precise computation for the kind of reference count.

TypeBase::usesNativeReferenceCounting() was doing a lot of work to
find the class that a type refers to, then determine whether it
would use the native reference-counting scheme. Its primary caller
in IRGen would use an overly-conservative approximation to decide
between the “Objective-C” and “unknown” cases, which resulted in
uses of “unknown” reference counting for some obviously-ObjC cases
(e.g., values of “NSObject”).

Moreover, the approximation would try to call into the type checker
(because it relied unnecessarily on the superclass *type* of a class
declaration), causing an assertion.

Fixes rdar://problem/42828798.

Author: DougGregor

include/swift/AST/ReferenceCounting.h

@@ -0,0 +1,63 @@
+//===--- ReferenceCounting.h ------------------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_REFERENCE_COUNTING_H
+#define SWIFT_AST_REFERENCE_COUNTING_H
+
+namespace swift {
+
+/// The kind of reference counting implementation a heap object uses.
+enum class ReferenceCounting : uint8_t {
+  /// The object uses native Swift reference counting.
+  Native,
+
+  /// The object uses ObjC reference counting.
+  ///
+  /// When ObjC interop is enabled, native Swift class objects are also ObjC
+  /// reference counting compatible. Swift non-class heap objects are never
+  /// ObjC reference counting compatible.
+  ///
+  /// Blocks are always ObjC reference counting compatible.
+  ObjC,
+
+  /// The object uses _Block_copy/_Block_release reference counting.
+  ///
+  /// This is a strict subset of ObjC; all blocks are also ObjC reference
+  /// counting compatible. The block is assumed to have already been moved to
+  /// the heap so that _Block_copy returns the same object back.
+  Block,
+
+  /// The object has an unknown reference counting implementation.
+  ///
+  /// This uses maximally-compatible reference counting entry points in the
+  /// runtime.
+  Unknown,
+
+  /// Cases prior to this one are binary-compatible with Unknown reference
+  /// counting.
+  LastUnknownCompatible = Unknown,
+
+  /// The object has an unknown reference counting implementation and
+  /// the reference value may contain extra bits that need to be masked.
+  ///
+  /// This uses maximally-compatible reference counting entry points in the
+  /// runtime, with a masking layer on top. A bit inside the pointer is used
+  /// to signal native Swift refcounting.
+  Bridge,
+
+  /// The object uses ErrorType's reference counting entry points.
+  Error,
+};
+
+} // end namespace swift
+
+#endif

include/swift/AST/Types.h

@@ -54,6 +54,7 @@ namespace swift {
   class GenericParamList;
   class GenericSignature;
   class Identifier;
+  enum class ReferenceCounting : uint8_t;
   enum class ResilienceExpansion : unsigned;
   class SILModule;
   class SILType;
@@ -843,6 +844,10 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// Swift-native reference counting?
   bool usesNativeReferenceCounting(ResilienceExpansion resilience);
 
+  /// Given that this type is a reference type, which kind of reference
+  /// counting does it use?
+  ReferenceCounting getReferenceCounting(ResilienceExpansion resilience);
+
   /// Determines whether this type has a bridgeable object
   /// representation, i.e., whether it is always represented as a single
   /// (non-nil) pointer that can be unknown-retained and

lib/AST/Type.cpp

@@ -19,6 +19,7 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/GenericSignatureBuilder.h"
+#include "swift/AST/ReferenceCounting.h"
 #include "swift/AST/TypeVisitor.h"
 #include "swift/AST/TypeWalker.h"
 #include "swift/AST/Decl.h"
@@ -4046,21 +4047,31 @@ bool UnownedStorageType::isLoadable(ResilienceExpansion resilience) const {
   return ty->usesNativeReferenceCounting(resilience);
 }
 
-static bool doesOpaqueClassUseNativeReferenceCounting(const ASTContext &ctx) {
-  return !ctx.LangOpts.EnableObjCInterop;
-}
-
-static bool usesNativeReferenceCounting(ClassDecl *theClass,
-                                        ResilienceExpansion resilience) {
+static ReferenceCounting getClassReferenceCounting(
+                                             ClassDecl *theClass,
+                                             ResilienceExpansion resilience) {
   // TODO: Resilience? there might be some legal avenue of changing this.
   while (auto superclass = theClass->getSuperclassDecl()) {
     theClass = superclass;
   }
-  return !theClass->hasClangNode();
+
+  return theClass->hasClangNode()
+           ? ReferenceCounting::ObjC
+           : ReferenceCounting::Native;
 }
 
-bool TypeBase::usesNativeReferenceCounting(ResilienceExpansion resilience) {
+ReferenceCounting TypeBase::getReferenceCounting(
+                                              ResilienceExpansion resilience) {
   CanType type = getCanonicalType();
+  ASTContext &ctx = type->getASTContext();
+
+  // Determine which reference-counting scheme to use for an unknown object.
+  bool objCInterop = ctx.LangOpts.EnableObjCInterop;
+  auto getUnknownObjectReferenceCounting = [objCInterop] {
+    return objCInterop ? ReferenceCounting::Unknown
+                       : ReferenceCounting::Native;
+  };
+
   switch (type->getKind()) {
 #define SUGARED_TYPE(id, parent) case TypeKind::id:
 #define TYPE(id, parent)
@@ -4069,27 +4080,30 @@ bool TypeBase::usesNativeReferenceCounting(ResilienceExpansion resilience) {
 
   case TypeKind::BuiltinNativeObject:
   case TypeKind::SILBox:
-    return true;
+    return ReferenceCounting::Native;
 
-  case TypeKind::BuiltinUnknownObject:
   case TypeKind::BuiltinBridgeObject:
-    return ::doesOpaqueClassUseNativeReferenceCounting(type->getASTContext());
+    return objCInterop ? ReferenceCounting::Bridge
+                       : ReferenceCounting::Native;
+
+  case TypeKind::BuiltinUnknownObject:
+    return getUnknownObjectReferenceCounting();
 
   case TypeKind::Class:
-    return ::usesNativeReferenceCounting(cast<ClassType>(type)->getDecl(),
-                                         resilience);
+    return getClassReferenceCounting(cast<ClassType>(type)->getDecl(),
+                                     resilience);
   case TypeKind::BoundGenericClass:
-    return ::usesNativeReferenceCounting(
+    return getClassReferenceCounting(
                                   cast<BoundGenericClassType>(type)->getDecl(),
-                                         resilience);
+                                  resilience);
   case TypeKind::UnboundGeneric:
-    return ::usesNativeReferenceCounting(
+    return getClassReferenceCounting(
                     cast<ClassDecl>(cast<UnboundGenericType>(type)->getDecl()),
-                                         resilience);
+                    resilience);
 
   case TypeKind::DynamicSelf:
     return cast<DynamicSelfType>(type).getSelfType()
-             ->usesNativeReferenceCounting(resilience);
+        ->getReferenceCounting(resilience);
 
   case TypeKind::Archetype: {
     auto archetype = cast<ArchetypeType>(type);
@@ -4098,17 +4112,17 @@ bool TypeBase::usesNativeReferenceCounting(ResilienceExpansion resilience) {
     assert(archetype->requiresClass() ||
            (layout && layout->isRefCounted()));
     if (auto supertype = archetype->getSuperclass())
-      return supertype->usesNativeReferenceCounting(resilience);
-    return ::doesOpaqueClassUseNativeReferenceCounting(type->getASTContext());
+      return supertype->getReferenceCounting(resilience);
+    return getUnknownObjectReferenceCounting();
   }
 
   case TypeKind::Protocol:
   case TypeKind::ProtocolComposition: {
-    auto layout = getExistentialLayout();
+    auto layout = type->getExistentialLayout();
     assert(layout.requiresClass() && "Opaque existentials don't use refcounting");
     if (auto superclass = layout.getSuperclass())
-      return superclass->usesNativeReferenceCounting(resilience);
-    return ::doesOpaqueClassUseNativeReferenceCounting(type->getASTContext());
+      return superclass->getReferenceCounting(resilience);
+    return getUnknownObjectReferenceCounting();
   }
 
   case TypeKind::Function:
@@ -4145,6 +4159,10 @@ bool TypeBase::usesNativeReferenceCounting(ResilienceExpansion resilience) {
   llvm_unreachable("Unhandled type kind!");
 }
 
+bool TypeBase::usesNativeReferenceCounting(ResilienceExpansion resilience) {
+  return getReferenceCounting(resilience) == ReferenceCounting::Native;
+}
+
 //
 // SILBoxType implementation
 //

lib/IRGen/GenClass.cpp

@@ -63,22 +63,7 @@ using namespace irgen;
 /// What reference counting mechanism does a class-like type have?
 ReferenceCounting irgen::getReferenceCountingForType(IRGenModule &IGM,
                                                      CanType type) {
-  // If ObjC interop is disabled, we have a Swift refcount.
-  if (!IGM.ObjCInterop)
-    return ReferenceCounting::Native;
-
-  if (type->usesNativeReferenceCounting(ResilienceExpansion::Maximal))
-    return ReferenceCounting::Native;
-
-  // Class-constrained archetypes and existentials that don't use
-  // native reference counting and yet have a superclass must be
-  // using ObjC reference counting.
-  auto superclass = type->getSuperclass();
-  if (superclass)
-    return ReferenceCounting::ObjC;
-
-  // Otherwise, it could be either one.
-  return ReferenceCounting::Unknown;
+  return type->getReferenceCounting(ResilienceExpansion::Maximal);
 }
 
 namespace {

lib/IRGen/GenClass.h

@@ -48,7 +48,6 @@ namespace irgen {
   class StructLayout;
   class TypeInfo;
 
-  enum class ReferenceCounting : unsigned char;
   enum class ClassDeallocationKind : unsigned char;
   enum class FieldAccess : uint8_t;
 

lib/IRGen/IRGen.h

@@ -82,49 +82,6 @@ enum IsABIAccessible_t : bool {
   IsABIAccessible = true  
 };
 
-/// The kind of reference counting implementation a heap object uses.
-enum class ReferenceCounting : uint8_t {
-  /// The object uses native Swift reference counting.
-  Native,
-
-  /// The object uses ObjC reference counting.
-  ///
-  /// When ObjC interop is enabled, native Swift class objects are also ObjC
-  /// reference counting compatible. Swift non-class heap objects are never
-  /// ObjC reference counting compatible.
-  ///
-  /// Blocks are always ObjC reference counting compatible.
-  ObjC,
-
-  /// The object uses _Block_copy/_Block_release reference counting.
-  ///
-  /// This is a strict subset of ObjC; all blocks are also ObjC reference
-  /// counting compatible. The block is assumed to have already been moved to
-  /// the heap so that _Block_copy returns the same object back.
-  Block,
-
-  /// The object has an unknown reference counting implementation.
-  ///
-  /// This uses maximally-compatible reference counting entry points in the
-  /// runtime.
-  Unknown,
-
-  /// Cases prior to this one are binary-compatible with Unknown reference
-  /// counting.
-  LastUnknownCompatible = Unknown,
-
-  /// The object has an unknown reference counting implementation and
-  /// the reference value may contain extra bits that need to be masked.
-  ///
-  /// This uses maximally-compatible reference counting entry points in the
-  /// runtime, with a masking layer on top. A bit inside the pointer is used
-  /// to signal native Swift refcounting.
-  Bridge,
-
-  /// The object uses ErrorType's reference counting entry points.
-  Error,
-};
-
 /// The atomicity of a reference counting operation to be used.
 enum class Atomicity : bool {
   /// Atomic reference counting operations should be used.

lib/IRGen/IRGenFunction.h

@@ -60,7 +60,6 @@ namespace irgen {
   class Scope;
   class TypeInfo;
   enum class ValueWitness : unsigned;
-  enum class ReferenceCounting : unsigned char;
 
 /// IRGenFunction - Primary class for emitting LLVM instructions for a
 /// specific function.

lib/IRGen/IRGenModule.h

@@ -22,6 +22,7 @@
 #include "SwiftTargetInfo.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Module.h"
+#include "swift/AST/ReferenceCounting.h"
 #include "swift/Basic/ClusteredBitVector.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/OptimizationMode.h"
@@ -133,7 +134,6 @@ namespace irgen {
   class TypeConverter;
   class TypeInfo;
   enum class ValueWitness : unsigned;
-  enum class ReferenceCounting : unsigned char;
 
 class IRGenModule;
 

lib/IRGen/TypeInfo.h

@@ -26,6 +26,7 @@
 #define SWIFT_IRGEN_TYPEINFO_H
 
 #include "IRGen.h"
+#include "swift/AST/ReferenceCounting.h"
 #include "llvm/ADT/MapVector.h"
 
 namespace llvm {

test/IRGen/Inputs/objc_layout_other.swift

@@ -0,0 +1,3 @@
+import Foundation
+
+@objc class Bar : NSObject { }