Handle default actors by special-casing layout in IRGen instead

of adding a property.

This better matches what the actual implementation expects,
and it avoids some possibilities of weird mismatches.  However,
it also requires special-case initialization, destruction, and
dynamic-layout support, none of which I've added yet.

In order to get NSObject default actor subclasses to use Swift
refcounting (and thus avoid the need for the default actor runtime
to generally use ObjC refcounting), I've had to introduce a
SwiftNativeNSObject which we substitute as the superclass when
inheriting directly from NSObject.  This is something we could
do in all NSObject subclasses; for now, I'm just doing it in
actors, although it's all actors and not just default actors.
We are not yet taking advantage of our special knowledge of this
class anywhere except the reference-counting code.

I went around in circles exploring a number of alternatives for
doing this; at one point I basically had a completely parallel
"ForImplementation" superclass query.  That proved to be a lot
of added complexity and created more problems than it solved.
We also don't *really* get any benefit from this subclassing
because there still wouldn't be a consistent superclass for all
actors.  So instead it's very ad-hoc.

Author: rjmccall

include/swift/ABI/Actor.h

@@ -22,8 +22,9 @@
 
 namespace swift {
 
-/// The default actor implementation.
-class alignas(MaximumAlignment) DefaultActor : public HeapObject {
+/// The default actor implementation.  This is the layout of both
+/// the DefaultActor and NSDefaultActor classes.
+class alignas(Alignment_DefaultActor) DefaultActor : public HeapObject {
 public:
   // These constructors do not initialize the actor instance, and the
   // destructor does not destroy the actor instance; you must call

include/swift/ABI/MetadataValues.h

@@ -118,6 +118,9 @@ enum class NominalTypeKind : uint32_t {
 /// The maximum supported type alignment.
 const size_t MaximumAlignment = 16;
 
+/// The alignment of a DefaultActor.
+const size_t Alignment_DefaultActor = MaximumAlignment;
+
 /// Flags stored in the value-witness table.
 template <typename int_type>
 class TargetValueWitnessFlags {

include/swift/AST/ASTContext.h

@@ -580,7 +580,7 @@ class ASTContext final {
 
   // Retrieve the declaration of Swift._stdlib_isOSVersionAtLeast.
   FuncDecl *getIsOSVersionAtLeastDecl() const;
-  
+
   /// Look for the declaration with the given name within the
   /// Swift module.
   void lookupInSwiftModule(StringRef name,

include/swift/AST/Decl.h

@@ -3459,6 +3459,10 @@ enum class AncestryFlags : uint8_t {
 
   /// The class or one of its superclasses requires stored property initializers.
   RequiresStoredPropertyInits = (1<<6),
+
+  /// The class uses the ObjC object model (reference counting,
+  /// isa encoding, etc.).
+  ObjCObjectModel = (1<<7),
 };
 
 /// Return type of ClassDecl::checkAncestry(). Describes a set of interesting
@@ -3625,6 +3629,30 @@ class ClassDecl final : public NominalTypeDecl {
   /// Whether the class is an actor.
   bool isActor() const;
 
+  /// Whether the class is (known to be) a default actor.
+  bool isDefaultActor() const;
+
+  /// Whether the class is known to be a *root* default actor,
+  /// i.e. the first class in its hierarchy that is a default actor.
+  bool isRootDefaultActor() const;
+
+  /// Does this class explicitly declare any of the methods that
+  /// would prevent it from being a default actor?
+  bool hasExplicitCustomActorMethods() const;
+
+  /// Is this the NSObject class type?
+  bool isNSObject() const;
+
+  /// Whether the class directly inherits from NSObject but should use
+  /// Swift's native object model.
+  bool isNativeNSObjectSubclass() const;
+
+  /// Whether the class uses the ObjC object model (reference counting,
+  /// allocation, etc.) instead of the Swift model.
+  bool usesObjCObjectModel() const {
+    return checkAncestry(AncestryFlags::ObjCObjectModel);
+  }
+
   /// Returns true if the class has designated initializers that are not listed
   /// in its members.
   ///

include/swift/AST/DiagnosticsCommon.def

@@ -103,6 +103,10 @@ ERROR(generic_signature_not_equal,none,
       "generic signature %0 is not equal to new signature %1",
       (StringRef, StringRef))
 
+// Used in diagnostics that are split across requests implemented in several places.
+ERROR(concurrency_default_actor_not_found,none,
+      "broken standard library: cannot find default actor type '%0'", (StringRef))
+
 // FIXME: Used by swift-api-digester. Don't want to set up a separate diagnostics
 // file just for a few errors.
 ERROR(sdk_node_unrecognized_key,none,

include/swift/AST/KnownIdentifiers.def

@@ -127,6 +127,7 @@ IDENTIFIER(super)
 IDENTIFIER(superDecoder)
 IDENTIFIER(superEncoder)
 IDENTIFIER_WITH_NAME(SwiftObject, "_TtCs12_SwiftObject")
+IDENTIFIER(SwiftNativeNSObject)
 IDENTIFIER(to)
 IDENTIFIER(toRaw)
 IDENTIFIER(Type)
@@ -142,7 +143,6 @@ IDENTIFIER(withKeywordArguments)
 IDENTIFIER(wrapped)
 IDENTIFIER(wrappedValue)
 IDENTIFIER(wrapperValue)
-IDENTIFIER_WITH_NAME(actorStorage, "$__actor_storage")
 
 // Kinds of layout constraints
 IDENTIFIER_WITH_NAME(UnknownLayout, "_UnknownLayout")
@@ -206,6 +206,10 @@ IDENTIFIER(arrayLiteral)
 IDENTIFIER(dictionaryLiteral)
 IDENTIFIER(className)
 
+IDENTIFIER(_defaultActorInitialize)
+IDENTIFIER(_defaultActorDestroy)
+IDENTIFIER(_defaultActorEnqueue)
+
 IDENTIFIER_(ErrorType)
 IDENTIFIER(Code)
 IDENTIFIER_(nsError)

include/swift/AST/TypeCheckRequests.h

@@ -853,6 +853,24 @@ class IsActorRequest :
   bool isCached() const { return true; }
 };
 
+/// Determine whether the given class is a default actor.
+class IsDefaultActorRequest :
+    public SimpleRequest<IsDefaultActorRequest,
+                         bool(ClassDecl *),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  bool evaluate(Evaluator &evaluator, ClassDecl *classDecl) const;
+
+public:
+  // Caching
+  bool isCached() const { return true; }
+};
+
 /// Retrieve the static "shared" property within a global actor that provides
 /// the actor instance representing the global actor.
 ///

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -89,6 +89,8 @@ SWIFT_REQUEST(TypeChecker, CanBeAsyncHandlerRequest, bool(FuncDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsActorRequest, bool(ClassDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, IsDefaultActorRequest, bool(ClassDecl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GlobalActorInstanceRequest,
               VarDecl *(NominalTypeDecl *),
               Cached, NoLocationInfo)

lib/AST/ASTContext.cpp

@@ -227,6 +227,12 @@ struct ASTContext::Implementation {
   /// The declaration of Swift.AutoreleasingUnsafeMutablePointer<T>.memory.
   VarDecl *AutoreleasingUnsafeMutablePointerMemoryDecl = nullptr;
 
+  /// The declaration of _Concurrency.DefaultActor.
+  ClassDecl *DefaultActorDecl = nullptr;
+
+  /// The declaration of _Concurrency.NSObjectDefaultActor.
+  ClassDecl *NSObjectDefaultActorDecl = nullptr;
+
   // Declare cached declarations for each of the known declarations.
 #define FUNC_DECL(Name, Id) FuncDecl *Get##Name = nullptr;
 #include "swift/AST/KnownDecls.def"

lib/AST/ASTMangler.cpp

@@ -1837,6 +1837,13 @@ ASTMangler::getSpecialManglingContext(const ValueDecl *decl,
         return ASTMangler::ObjCContext;
       }
     }
+
+    // Types apparently defined in the Builtin module are actually
+    // synthetic declarations for types defined in the runtime,
+    // and they should be mangled as C-namespace entities; see e.g.
+    // IRGenModule::getObjCRuntimeBaseClass.
+    if (decl->getModuleContext()->isBuiltinModule())
+      return ASTMangler::ObjCContext;
   }
 
   // Importer-synthesized types should always be mangled in the