Eliminate Builtin.UnknownObject as an AST type (swiftlang#27378)

This removes it from the AST and largely replaces it with AnyObject
at the SIL and IRGen layers. Some notes:

- Reflection still uses the notion of "unknown object" to mean an
  object with unknown refcounting. There's no real reason to make
  this different from AnyObject (an existential containing a
  single object with unknown refcounting), but this way nothing
  changes for clients of Reflection, and it's consistent with how
  native objects are represented.

- The value witness table and reflection descriptor for AnyObject
  use the mangling "BO" instead of "yXl".

- The demangler and remangler continue to support "BO" because it's
  still in use as a type encoding, even if it's not an AST-level
  Type anymore.

- Type-based alias analysis for Builtin.UnknownObject was incorrect,
  so it's a good thing we weren't using it.

- Same with enum layout. (This one assumed UnknownObject never
  referred to an Objective-C tagged pointer. That certainly wasn't how
  we were using it!)

Author: jrose-apple

docs/ABI/Mangling.rst

@@ -481,7 +481,7 @@ Types
   type ::= 'Bf' NATURAL '_'                  // Builtin.Float<n>
   type ::= 'Bi' NATURAL '_'                  // Builtin.Int<n>
   type ::= 'BI'                              // Builtin.IntLiteral
-  type ::= 'BO'                              // Builtin.UnknownObject
+  type ::= 'BO'                              // Builtin.UnknownObject (no longer a distinct type, but still used for AnyObject)
   type ::= 'Bo'                              // Builtin.NativeObject
   type ::= 'Bp'                              // Builtin.RawPointer
   type ::= 'Bt'                              // Builtin.SILToken

docs/ARCOptimization.rst

@@ -335,7 +335,7 @@ is_unique performs depends on the argument type:
 
     - Objective-C object types require an additional check that the
       dynamic object type uses native Swift reference counting:
-      (Builtin.UnknownObject, unknown class reference, class existential)
+      (unknown class reference, class existential)
 
     - Bridged object types allow the dynamic object type check to be
       bypassed based on the pointer encoding:

include/swift/AST/ASTContext.h

@@ -605,7 +605,6 @@ class ASTContext final {
   const CanType TheAnyType;               /// This is 'Any', the empty protocol composition
   const CanType TheNativeObjectType;      /// Builtin.NativeObject
   const CanType TheBridgeObjectType;      /// Builtin.BridgeObject
-  const CanType TheUnknownObjectType;     /// Builtin.UnknownObject
   const CanType TheRawPointerType;        /// Builtin.RawPointer
   const CanType TheUnsafeValueBufferType; /// Builtin.UnsafeValueBuffer
   const CanType TheSILTokenType;          /// Builtin.SILToken

include/swift/AST/TypeMatcher.h

@@ -107,7 +107,6 @@ class TypeMatcher {
     TRIVIAL_CASE(BuiltinRawPointerType)
     TRIVIAL_CASE(BuiltinNativeObjectType)
     TRIVIAL_CASE(BuiltinBridgeObjectType)
-    TRIVIAL_CASE(BuiltinUnknownObjectType)
     TRIVIAL_CASE(BuiltinUnsafeValueBufferType)
     TRIVIAL_CASE(BuiltinVectorType)
     TRIVIAL_CASE(SILTokenType)

include/swift/AST/TypeNodes.def

@@ -98,7 +98,6 @@ ABSTRACT_TYPE(Builtin, Type)
   BUILTIN_TYPE(BuiltinRawPointer, BuiltinType)
   BUILTIN_TYPE(BuiltinNativeObject, BuiltinType)
   BUILTIN_TYPE(BuiltinBridgeObject, BuiltinType)
-  BUILTIN_TYPE(BuiltinUnknownObject, BuiltinType)
   BUILTIN_TYPE(BuiltinUnsafeValueBuffer, BuiltinType)
   BUILTIN_TYPE(BuiltinVector, BuiltinType)
   TYPE_RANGE(Builtin, BuiltinInteger, BuiltinVector)

include/swift/AST/Types.h

@@ -1311,19 +1311,6 @@ class BuiltinBridgeObjectType : public BuiltinType {
 };
 DEFINE_EMPTY_CAN_TYPE_WRAPPER(BuiltinBridgeObjectType, BuiltinType);
 
-/// BuiltinUnknownObjectType - The builtin opaque Objective-C pointer type.
-/// Useful for pushing an Objective-C type through swift.
-class BuiltinUnknownObjectType : public BuiltinType {
-  friend class ASTContext;
-  BuiltinUnknownObjectType(const ASTContext &C)
-    : BuiltinType(TypeKind::BuiltinUnknownObject, C) {}
-public:
-  static bool classof(const TypeBase *T) {
-    return T->getKind() == TypeKind::BuiltinUnknownObject;
-  }
-};
-DEFINE_EMPTY_CAN_TYPE_WRAPPER(BuiltinUnknownObjectType, BuiltinType);
-
 /// BuiltinUnsafeValueBufferType - The builtin opaque fixed-size value
 /// buffer type, into which storage for an arbitrary value can be
 /// allocated using Builtin.allocateValueBuffer.

include/swift/Reflection/ReflectionContext.h

@@ -671,7 +671,7 @@ class ReflectionContext
     // Class existentials have trivial layout.
     // It is itself the pointer to the instance followed by the witness tables.
     case RecordKind::ClassExistential:
-      // This is just Builtin.UnknownObject
+      // This is just AnyObject.
       *OutInstanceTR = ExistentialRecordTI->getFields()[0].TR;
       *OutInstanceAddress = ExistentialAddress;
       return true;

include/swift/Runtime/BuiltinTypes.def

@@ -56,6 +56,8 @@ BUILTIN_POINTER_TYPE(Bb, "Builtin.BridgeObject")
 BUILTIN_POINTER_TYPE(Bp, "Builtin.RawPointer")
 BUILTIN_TYPE(BB, "Builtin.UnsafeValueBuffer")
 
+// No longer used in the compiler as an AST type, but still used for fields 
+// shaped like AnyObject (normal mangling yXl).
 BUILTIN_POINTER_TYPE(BO, "Builtin.UnknownObject")
 
 // Int8 vector types

include/swift/SIL/SILType.h

@@ -512,8 +512,6 @@ class SILType {
 
   /// Get the NativeObject type as a SILType.
   static SILType getNativeObjectType(const ASTContext &C);
-  /// Get the UnknownObject type as a SILType.
-  static SILType getUnknownObjectType(const ASTContext &C);
   /// Get the BridgeObject type as a SILType.
   static SILType getBridgeObjectType(const ASTContext &C);
   /// Get the RawPointer type as a SILType.

include/swift/Strings.h

@@ -106,6 +106,9 @@ constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_RAWPOINTER = {
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_UNSAFEVALUEBUFFER =
     {"Builtin.UnsafeValueBuffer"};
 /// The name of the Builtin type for UnknownObject
+///
+/// This no longer exists as an AST-accessible type, but it's still used for 
+/// fields shaped like AnyObject when ObjC interop is enabled.
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_UNKNOWNOBJECT = {
     "Builtin.UnknownObject"};
 /// The name of the Builtin type for Vector