Freeze PartialAsyncTask as a Job*.

Also fix the extra inhabitants of Builtin.RawUnsafeContinuation
and try to make adding types like this a little less boiler-plate
in the future.

Author: rjmccall

docs/ABI/Mangling.rst

@@ -492,13 +492,14 @@ Types
 
   type ::= 'Bb'                              // Builtin.BridgeObject
   type ::= 'BB'                              // Builtin.UnsafeValueBuffer
+  type ::= 'Bc'                              // Builtin.RawUnsafeContinuation
   type ::= 'Bf' NATURAL '_'                  // Builtin.Float<n>
   type ::= 'Bi' NATURAL '_'                  // Builtin.Int<n>
   type ::= 'BI'                              // Builtin.IntLiteral
+  type ::= 'Bj'                              // Builtin.Job
   type ::= 'BO'                              // Builtin.UnknownObject (no longer a distinct type, but still used for AnyObject)
   type ::= 'Bo'                              // Builtin.NativeObject
   type ::= 'Bp'                              // Builtin.RawPointer
-  type ::= 'Bc'                              // Builtin.RawUnsafeContinuation
   type ::= 'Bt'                              // Builtin.SILToken
   type ::= type 'Bv' NATURAL '_'             // Builtin.Vec<n>x<type>
   type ::= 'Bw'                              // Builtin.Word

include/swift/AST/ASTContext.h

@@ -748,14 +748,10 @@ class ASTContext final {
   const CanType TheUnresolvedType;        /// This is the UnresolvedType singleton.
   const CanType TheEmptyTupleType;        /// This is '()', aka Void
   const CanType TheAnyType;               /// This is 'Any', the empty protocol composition
-  const CanType TheNativeObjectType;      /// Builtin.NativeObject
-  const CanType TheBridgeObjectType;      /// Builtin.BridgeObject
-  const CanType TheRawPointerType;        /// Builtin.RawPointer
-  const CanType TheRawUnsafeContinuationType; /// Builtin.RawUnsafeContinuation
-  const CanType TheUnsafeValueBufferType; /// Builtin.UnsafeValueBuffer
-  const CanType TheSILTokenType;          /// Builtin.SILToken
-  const CanType TheIntegerLiteralType;    /// Builtin.IntegerLiteralType
-  
+#define SINGLETON_TYPE(SHORT_ID, ID) \
+  const CanType The##SHORT_ID##Type;
+#include "swift/AST/TypeNodes.def"
+
   const CanType TheIEEE32Type;            /// 32-bit IEEE floating point
   const CanType TheIEEE64Type;            /// 64-bit IEEE floating point
 

include/swift/AST/TypeDifferenceVisitor.h

@@ -107,18 +107,11 @@ class CanTypeDifferenceVisitor : public CanTypePairVisitor<Impl, bool> {
   // non-identical types.
 
   // These types are singleton and can't actually differ.
-#define SINGLETON_TYPE(TYPE)                                  \
-  bool visit##TYPE(Can##TYPE type1, Can##TYPE type2) {        \
+#define SINGLETON_TYPE(SHORT_ID, ID)                               \
+  bool visit##ID##Type(Can##ID##Type type1, Can##ID##Type type2) {\
     llvm_unreachable("singleton type that wasn't identical"); \
   }
-  SINGLETON_TYPE(BuiltinIntegerLiteralType)
-  SINGLETON_TYPE(BuiltinRawPointerType)
-  SINGLETON_TYPE(BuiltinRawUnsafeContinuationType)
-  SINGLETON_TYPE(BuiltinNativeObjectType)
-  SINGLETON_TYPE(BuiltinBridgeObjectType)
-  SINGLETON_TYPE(BuiltinUnsafeValueBufferType)
-  SINGLETON_TYPE(SILTokenType)
-#undef SINGLETON_TYPE
+#include "swift/AST/TypeNodes.def"
 
   bool visitBuiltinIntegerType(CanBuiltinIntegerType type1,
                                CanBuiltinIntegerType type2) {

include/swift/AST/TypeMatcher.h

@@ -102,15 +102,10 @@ class TypeMatcher {
 
     TRIVIAL_CASE(ErrorType)
     TRIVIAL_CASE(BuiltinIntegerType)
-    TRIVIAL_CASE(BuiltinIntegerLiteralType)
     TRIVIAL_CASE(BuiltinFloatType)
-    TRIVIAL_CASE(BuiltinRawPointerType)
-    TRIVIAL_CASE(BuiltinRawUnsafeContinuationType)
-    TRIVIAL_CASE(BuiltinNativeObjectType)
-    TRIVIAL_CASE(BuiltinBridgeObjectType)
-    TRIVIAL_CASE(BuiltinUnsafeValueBufferType)
     TRIVIAL_CASE(BuiltinVectorType)
-    TRIVIAL_CASE(SILTokenType)
+#define SINGLETON_TYPE(SHORT_ID, ID) TRIVIAL_CASE(ID##Type)
+#include "swift/AST/TypeNodes.def"
 
     bool visitUnresolvedType(CanUnresolvedType firstType, Type secondType,
                              Type sugaredFirstType) {

include/swift/AST/TypeNodes.def

@@ -47,6 +47,12 @@
 ///   programs and it cannot be the type of an expression.
 ///   The default behavior is TYPE(id, parent).
 
+/// SINGLETON_TYPE(SHORT_ID, id)
+///   This type is a singleton, i.e. there is exactly one instance of
+///   it, which can be found as ASTContext.The#SHORT_ID#Type.
+///   This is only expanded if SINGLETON_TYPE is defined, and in this
+///   case no other macros are expanded.
+
 #ifndef ALWAYS_CANONICAL_TYPE
 #define ALWAYS_CANONICAL_TYPE(id, parent) TYPE(id, parent)
 #endif
@@ -87,6 +93,8 @@
 #define LAST_TYPE(Id)
 #endif
 
+#if !defined(SINGLETON_TYPE)
+
 TYPE(Error, Type)
 UNCHECKED_TYPE(Unresolved, Type)
 UNCHECKED_TYPE(Hole, Type)
@@ -96,6 +104,7 @@ ABSTRACT_TYPE(Builtin, Type)
     BUILTIN_TYPE(BuiltinIntegerLiteral, AnyBuiltinIntegerType)
     TYPE_RANGE(AnyBuiltinInteger, BuiltinInteger, BuiltinIntegerLiteral)
   BUILTIN_TYPE(BuiltinFloat, BuiltinType)
+  BUILTIN_TYPE(BuiltinJob, BuiltinType)
   BUILTIN_TYPE(BuiltinRawPointer, BuiltinType)
   BUILTIN_TYPE(BuiltinRawUnsafeContinuation, BuiltinType)
   BUILTIN_TYPE(BuiltinNativeObject, BuiltinType)
@@ -166,6 +175,20 @@ ABSTRACT_SUGARED_TYPE(Sugar, Type)
   TYPE_RANGE(Sugar, Paren, Dictionary)
 LAST_TYPE(Dictionary) // Sugared types are last to make isa<SugarType>() fast.
 
+#endif
+
+#ifdef SINGLETON_TYPE
+SINGLETON_TYPE(IntegerLiteral, BuiltinIntegerLiteral)
+SINGLETON_TYPE(Job, BuiltinJob)
+SINGLETON_TYPE(RawPointer, BuiltinRawPointer)
+SINGLETON_TYPE(RawUnsafeContinuation, BuiltinRawUnsafeContinuation)
+SINGLETON_TYPE(NativeObject, BuiltinNativeObject)
+SINGLETON_TYPE(BridgeObject, BuiltinBridgeObject)
+SINGLETON_TYPE(UnsafeValueBuffer, BuiltinUnsafeValueBuffer)
+SINGLETON_TYPE(SILToken, SILToken)
+#undef SINGLETON_TYPE
+#endif
+
 #undef TYPE_RANGE
 #undef ABSTRACT_SUGARED_TYPE
 #undef ABSTRACT_TYPE

include/swift/AST/Types.h

@@ -1392,8 +1392,9 @@ class BuiltinRawPointerType : public BuiltinType {
 DEFINE_EMPTY_CAN_TYPE_WRAPPER(BuiltinRawPointerType, BuiltinType);
 
 /// BuiltinRawContinuationType - The builtin raw unsafe continuation type.
-/// This pointer is completely unmanaged, but is lowered with the same
-/// spare bits as an opaque object-pointer type.
+/// In C, this is a non-null AsyncTask*.  This pointer is completely
+/// unmanaged (the unresumed task is self-owning), but has more spare bits
+/// than Builtin.RawPointer.
 class BuiltinRawUnsafeContinuationType : public BuiltinType {
   friend class ASTContext;
   BuiltinRawUnsafeContinuationType(const ASTContext &C)
@@ -1405,6 +1406,20 @@ class BuiltinRawUnsafeContinuationType : public BuiltinType {
 };
 DEFINE_EMPTY_CAN_TYPE_WRAPPER(BuiltinRawUnsafeContinuationType, BuiltinType);
 
+/// BuiltinJobType - The builtin job type.  In C, this is a
+/// non-null Job*.  This pointer is completely unmanaged (the unscheduled
+/// job is self-owning), but has more spare bits than Builtin.RawPointer.
+class BuiltinJobType : public BuiltinType {
+  friend class ASTContext;
+  BuiltinJobType(const ASTContext &C)
+    : BuiltinType(TypeKind::BuiltinJob, C) {}
+public:
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::BuiltinJob;
+  }
+};
+DEFINE_EMPTY_CAN_TYPE_WRAPPER(BuiltinJobType, BuiltinType);
+
 /// BuiltinNativeObjectType - The builtin opaque object-pointer type.
 /// Useful for keeping an object alive when it is otherwise being
 /// manipulated via an unsafe pointer type.

include/swift/Strings.h

@@ -116,6 +116,9 @@ constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_RAWUNSAFECONTINUATIO
 /// The name of the Builtin type for UnsafeValueBuffer
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_UNSAFEVALUEBUFFER =
     {"Builtin.UnsafeValueBuffer"};
+/// The name of the Builtin type for Job
+constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_JOB = {
+    "Builtin.Job"};
 /// The name of the Builtin type for UnknownObject
 ///
 /// This no longer exists as an AST-accessible type, but it's still used for

lib/AST/ASTContext.cpp

@@ -595,20 +595,10 @@ ASTContext::ASTContext(LangOptions &langOpts, TypeCheckerOptions &typeckOpts,
     TheEmptyTupleType(TupleType::get(ArrayRef<TupleTypeElt>(), *this)),
     TheAnyType(ProtocolCompositionType::get(*this, ArrayRef<Type>(),
                                             /*HasExplicitAnyObject=*/false)),
-    TheNativeObjectType(new (*this, AllocationArena::Permanent)
-                           BuiltinNativeObjectType(*this)),
-    TheBridgeObjectType(new (*this, AllocationArena::Permanent)
-                           BuiltinBridgeObjectType(*this)),
-    TheRawPointerType(new (*this, AllocationArena::Permanent)
-                        BuiltinRawPointerType(*this)),
-    TheRawUnsafeContinuationType(new (*this, AllocationArena::Permanent)
-                                 BuiltinRawUnsafeContinuationType(*this)),
-    TheUnsafeValueBufferType(new (*this, AllocationArena::Permanent)
-                               BuiltinUnsafeValueBufferType(*this)),
-    TheSILTokenType(new (*this, AllocationArena::Permanent)
-                      SILTokenType(*this)),
-    TheIntegerLiteralType(new (*this, AllocationArena::Permanent)
-                               BuiltinIntegerLiteralType(*this)),
+#define SINGLETON_TYPE(SHORT_ID, ID) \
+    The##SHORT_ID##Type(new (*this, AllocationArena::Permanent) \
+                          ID##Type(*this)),
+#include "swift/AST/TypeNodes.def"
     TheIEEE32Type(new (*this, AllocationArena::Permanent)
                     BuiltinFloatType(BuiltinFloatType::IEEE32,*this)),
     TheIEEE64Type(new (*this, AllocationArena::Permanent)

lib/AST/ASTDumper.cpp

@@ -3560,6 +3560,7 @@ namespace {
     }
 
     TRIVIAL_TYPE_PRINTER(BuiltinIntegerLiteral, builtin_integer_literal)
+    TRIVIAL_TYPE_PRINTER(BuiltinJob, builtin_job)
     TRIVIAL_TYPE_PRINTER(BuiltinRawPointer, builtin_raw_pointer)
     TRIVIAL_TYPE_PRINTER(BuiltinRawUnsafeContinuation, builtin_raw_unsafe_continuation)
     TRIVIAL_TYPE_PRINTER(BuiltinNativeObject, builtin_native_object)

lib/AST/ASTMangler.cpp

@@ -973,6 +973,8 @@ void ASTMangler::appendType(Type type, const ValueDecl *forDecl) {
     }
     case TypeKind::BuiltinIntegerLiteral:
       return appendOperator("BI");
+    case TypeKind::BuiltinJob:
+      return appendOperator("Bj");
     case TypeKind::BuiltinRawPointer:
       return appendOperator("Bp");
     case TypeKind::BuiltinRawUnsafeContinuation: