[AST] Introduce PlaceholderType and ThePlaceholderType singleton

Author: Jumhyn

include/swift/AST/ASTContext.h

@@ -756,6 +756,7 @@ class ASTContext final {
   // Builtin type and simple types that are used frequently.
   const CanType TheErrorType;             /// This is the ErrorType singleton.
   const CanType TheUnresolvedType;        /// This is the UnresolvedType singleton.
+  const CanType ThePlaceholderType;
   const CanType TheEmptyTupleType;        /// This is '()', aka Void
   const CanType TheAnyType;               /// This is 'Any', the empty protocol composition
 #define SINGLETON_TYPE(SHORT_ID, ID) \

include/swift/AST/TypeNodes.def

@@ -97,6 +97,7 @@
 
 TYPE(Error, Type)
 UNCHECKED_TYPE(Unresolved, Type)
+UNCHECKED_TYPE(Placeholder, Type)
 UNCHECKED_TYPE(Hole, Type)
 ABSTRACT_TYPE(Builtin, Type)
   ABSTRACT_TYPE(AnyBuiltinInteger, BuiltinType)

include/swift/AST/Types.h

@@ -152,7 +152,10 @@ class RecursiveTypeProperties {
     /// This type contains a type hole.
     HasTypeHole          = 0x800,
 
-    Last_Property = HasTypeHole
+    /// This type contains a placeholder.
+    HasPlaceholder   = 0x1000,
+
+    Last_Property = HasPlaceholder
   };
   enum { BitWidth = countBitsUsed(Property::Last_Property) };
 
@@ -211,6 +214,9 @@ class RecursiveTypeProperties {
   /// type hole?
   bool hasTypeHole() const { return Bits & HasTypeHole; }
 
+  /// Does a type with these properties structurally contain a placeholder?
+  bool hasPlaceholder() const { return Bits & HasPlaceholder; }
+
   /// Returns the set of properties present in either set.
   friend RecursiveTypeProperties operator|(Property lhs, Property rhs) {
     return RecursiveTypeProperties(unsigned(lhs) | unsigned(rhs));
@@ -580,6 +586,11 @@ class alignas(1 << TypeAlignInBits) TypeBase {
     return getRecursiveProperties().hasUnresolvedType();
   }
 
+  /// Determine whether this type involves a \c PlaceholderType.
+  bool hasPlaceholder() const {
+    return getRecursiveProperties().hasPlaceholder();
+  }
+
   /// Determine whether this type involves a hole.
   bool hasHole() const { return getRecursiveProperties().hasTypeHole(); }
 
@@ -1351,6 +1362,20 @@ class UnresolvedType : public TypeBase {
 };
 DEFINE_EMPTY_CAN_TYPE_WRAPPER(UnresolvedType, Type)
 
+class PlaceholderType : public TypeBase {
+  friend class ASTContext;
+  // The Placeholder type is always canonical.
+  PlaceholderType(ASTContext &C)
+    : TypeBase(TypeKind::Placeholder, &C,
+        RecursiveTypeProperties(RecursiveTypeProperties::HasPlaceholder)) { }
+public:
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::Placeholder;
+  }
+};
+DEFINE_EMPTY_CAN_TYPE_WRAPPER(PlaceholderType, Type)
+
 
 /// BuiltinType - An abstract class for all the builtin types.
 class BuiltinType : public TypeBase {

lib/AST/ASTContext.cpp

@@ -595,6 +595,8 @@ ASTContext::ASTContext(LangOptions &langOpts, TypeCheckerOptions &typeckOpts,
         ErrorType(*this, Type(), RecursiveTypeProperties::HasError)),
     TheUnresolvedType(new (*this, AllocationArena::Permanent)
                       UnresolvedType(*this)),
+    ThePlaceholderType(new (*this, AllocationArena::Permanent)
+                       PlaceholderType(*this)),
     TheEmptyTupleType(TupleType::get(ArrayRef<TupleTypeElt>(), *this)),
     TheAnyType(ProtocolCompositionType::get(*this, ArrayRef<Type>(),
                                             /*HasExplicitAnyObject=*/false)),
@@ -3102,7 +3104,7 @@ isFunctionTypeCanonical(ArrayRef<AnyFunctionType::Param> params,
 static RecursiveTypeProperties
 getGenericFunctionRecursiveProperties(ArrayRef<AnyFunctionType::Param> params,
                                       Type result) {
-  static_assert(RecursiveTypeProperties::BitWidth == 12,
+  static_assert(RecursiveTypeProperties::BitWidth == 13,
                 "revisit this if you add new recursive type properties");
   RecursiveTypeProperties properties;
 
@@ -3676,7 +3678,7 @@ CanSILFunctionType SILFunctionType::get(
   void *mem = ctx.Allocate(bytes, alignof(SILFunctionType));
 
   RecursiveTypeProperties properties;
-  static_assert(RecursiveTypeProperties::BitWidth == 12,
+  static_assert(RecursiveTypeProperties::BitWidth == 13,
                 "revisit this if you add new recursive type properties");
   for (auto &param : params)
     properties |= param.getInterfaceType()->getRecursiveProperties();

lib/AST/ASTDumper.cpp

@@ -3535,6 +3535,8 @@ namespace {
 
     TRIVIAL_TYPE_PRINTER(Unresolved, unresolved)
 
+    TRIVIAL_TYPE_PRINTER(Placeholder, placeholder)
+
     void visitHoleType(HoleType *T, StringRef label) {
       printCommon(label, "hole_type");
       auto originator = T->getOriginator();

lib/AST/ASTMangler.cpp

@@ -966,6 +966,7 @@ void ASTMangler::appendType(Type type, const ValueDecl *forDecl) {
 
     case TypeKind::Error:
     case TypeKind::Unresolved:
+    case TypeKind::Placeholder:
       appendOperator("Xe");
       return;
 

lib/AST/ASTPrinter.cpp

@@ -4168,6 +4168,13 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       Printer << "_";
   }
 
+  void visitPlaceholderType(PlaceholderType *T) {
+    if (Options.PrintTypesForDebugging)
+      Printer << "<<placeholdertype>>";
+    else
+      Printer << "_";
+  }
+
   void visitHoleType(HoleType *T) {
     if (Options.PrintTypesForDebugging) {
       Printer << "<<hole for ";

lib/AST/Type.cpp

@@ -204,6 +204,7 @@ bool CanType::isReferenceTypeImpl(CanType type, const GenericSignatureImpl *sig,
   case TypeKind::SILBlockStorage:
   case TypeKind::Error:
   case TypeKind::Unresolved:
+  case TypeKind::Placeholder:
   case TypeKind::BuiltinInteger:
   case TypeKind::BuiltinIntegerLiteral:
   case TypeKind::BuiltinFloat:
@@ -1153,6 +1154,7 @@ CanType TypeBase::computeCanonicalType() {
 #include "swift/AST/TypeNodes.def"
   case TypeKind::Error:
   case TypeKind::Unresolved:
+  case TypeKind::Placeholder:
   case TypeKind::TypeVariable:
   case TypeKind::Hole:
     llvm_unreachable("these types are always canonical");
@@ -4275,6 +4277,7 @@ case TypeKind::Id:
   case TypeKind::OpenedArchetype:
   case TypeKind::Error:
   case TypeKind::Unresolved:
+  case TypeKind::Placeholder:
   case TypeKind::TypeVariable:
   case TypeKind::Hole:
   case TypeKind::GenericTypeParam:
@@ -5013,6 +5016,7 @@ ReferenceCounting TypeBase::getReferenceCounting() {
   case TypeKind::SILBlockStorage:
   case TypeKind::Error:
   case TypeKind::Unresolved:
+  case TypeKind::Placeholder:
   case TypeKind::BuiltinInteger:
   case TypeKind::BuiltinIntegerLiteral:
   case TypeKind::BuiltinFloat:

lib/AST/TypeWalker.cpp

@@ -34,6 +34,7 @@ class Traversal : public TypeVisitor<Traversal, bool>
 
   bool visitErrorType(ErrorType *ty) { return false; }
   bool visitUnresolvedType(UnresolvedType *ty) { return false; }
+  bool visitPlaceholderType(PlaceholderType *ty) { return false; }
   bool visitHoleType(HoleType *ty) { return false; }
   bool visitBuiltinType(BuiltinType *ty) { return false; }
   bool visitTypeAliasType(TypeAliasType *ty) {

lib/IRGen/IRGenDebugInfo.cpp

@@ -1629,6 +1629,7 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
     // checker.
     case TypeKind::Error:
     case TypeKind::Unresolved:
+    case TypeKind::Placeholder:
     case TypeKind::LValue:
     case TypeKind::TypeVariable:
     case TypeKind::Hole:

lib/Sema/CSSimplify.cpp

@@ -4901,6 +4901,9 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
     case TypeKind::Unresolved:
       return getTypeMatchFailure(locator);
 
+    case TypeKind::Placeholder:
+      llvm_unreachable("placeholders should already be converted to type vars");
+
     case TypeKind::Hole: {
       // If it's allowed to attempt fixes, let's delegate
       // decision to `repairFailures`, since depending on
@@ -5596,6 +5599,7 @@ ConstraintSystem::simplifyConstructionConstraint(
       llvm_unreachable("artificial type in constraint");
 
   case TypeKind::Unresolved:
+  case TypeKind::Placeholder:
   case TypeKind::Error:
   case TypeKind::Hole:
     return SolutionKind::Error;

lib/Serialization/Serialization.cpp

@@ -4109,6 +4109,10 @@ class Serializer::TypeSerializer : public TypeVisitor<TypeSerializer> {
     llvm_unreachable("should not serialize an UnresolvedType");
   }
 
+  void visitPlaceholderType(const PlaceholderType *) {
+    llvm_unreachable("should not serialize an invalid type");
+  }
+
   void visitHoleType(const HoleType *) {
     llvm_unreachable("should not serialize a HoleType");
   }