Rename HoleType to PlaceholderType

HoleType basically served the same purpose as PlaceholderType. This commit unifies the two.

Author: Jumhyn

include/swift/AST/ASTContext.h

@@ -756,7 +756,6 @@ 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

@@ -98,7 +98,6 @@
 TYPE(Error, Type)
 UNCHECKED_TYPE(Unresolved, Type)
 UNCHECKED_TYPE(Placeholder, Type)
-UNCHECKED_TYPE(Hole, Type)
 ABSTRACT_TYPE(Builtin, Type)
   ABSTRACT_TYPE(AnyBuiltinInteger, BuiltinType)
     BUILTIN_TYPE(BuiltinInteger, AnyBuiltinIntegerType)

include/swift/AST/Types.h

@@ -67,6 +67,7 @@ class Identifier;
 class InOutType;
 class OpaqueTypeDecl;
 class OpenedArchetypeType;
+class PlaceholderTypeRepr;
 enum class ReferenceCounting : uint8_t;
 enum class ResilienceExpansion : unsigned;
 class SILModule;
@@ -126,7 +127,7 @@ class RecursiveTypeProperties {
 
     /// This type expression contains an UnresolvedType.
     HasUnresolvedType    = 0x08,
-    
+
     /// Whether this type expression contains an unbound generic type.
     HasUnboundGeneric    = 0x10,
 
@@ -145,15 +146,12 @@ class RecursiveTypeProperties {
 
     /// This type contains a DependentMemberType.
     HasDependentMember   = 0x200,
-    
+
     /// This type contains an OpaqueTypeArchetype.
     HasOpaqueArchetype   = 0x400,
 
-    /// This type contains a type hole.
-    HasTypeHole          = 0x800,
-
-    /// This type contains a placeholder.
-    HasPlaceholder   = 0x1000,
+    /// This type contains a type placeholder.
+    HasPlaceholder       = 0x800,
 
     Last_Property = HasPlaceholder
   };
@@ -210,10 +208,6 @@ class RecursiveTypeProperties {
   /// generic type?
   bool hasUnboundGeneric() const { return Bits & HasUnboundGeneric; }
 
-  /// Does a type with these properties structurally contain a
-  /// type hole?
-  bool hasTypeHole() const { return Bits & HasTypeHole; }
-
   /// Does a type with these properties structurally contain a placeholder?
   bool hasPlaceholder() const { return Bits & HasPlaceholder; }
 
@@ -552,7 +546,7 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// Is this the 'Any' type?
   bool isAny();
 
-  bool isHole();
+  bool isPlaceholder();
 
   /// Does the type have outer parenthesis?
   bool hasParenSugar() const { return getKind() == TypeKind::Paren; }
@@ -591,9 +585,6 @@ class alignas(1 << TypeAlignInBits) TypeBase {
     return getRecursiveProperties().hasPlaceholder();
   }
 
-  /// Determine whether this type involves a hole.
-  bool hasHole() const { return getRecursiveProperties().hasTypeHole(); }
-
   /// Determine whether the type involves a context-dependent archetype.
   bool hasArchetype() const {
     return getRecursiveProperties().hasArchetype();
@@ -1362,20 +1353,6 @@ 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 {
@@ -5834,31 +5811,31 @@ TypeVariableType : public TypeBase {
 };
 DEFINE_EMPTY_CAN_TYPE_WRAPPER(TypeVariableType, Type)
 
-/// HoleType - This represents a placeholder type for a type variable
+/// PlaceholderType - This represents a placeholder type for a type variable
 /// or dependent member type that cannot be resolved to a concrete type
 /// because the expression is ambiguous. This type is only used by the
 /// constraint solver and transformed into UnresolvedType to be used in AST.
-class HoleType : public TypeBase {
-  using Originator = llvm::PointerUnion<TypeVariableType *,
-                                        DependentMemberType *, VarDecl *,
-                                        ErrorExpr *>;
+class PlaceholderType : public TypeBase {
+  using Originator =
+      llvm::PointerUnion<TypeVariableType *, DependentMemberType *, VarDecl *,
+                         ErrorExpr *, PlaceholderTypeRepr *>;
 
   Originator O;
 
-  HoleType(ASTContext &C, Originator originator,
-           RecursiveTypeProperties properties)
-      : TypeBase(TypeKind::Hole, &C, properties), O(originator) {}
+  PlaceholderType(ASTContext &C, Originator originator,
+                  RecursiveTypeProperties properties)
+      : TypeBase(TypeKind::Placeholder, &C, properties), O(originator) {}
 
 public:
   static Type get(ASTContext &ctx, Originator originator);
 
   Originator getOriginator() const { return O; }
 
   static bool classof(const TypeBase *T) {
-    return T->getKind() == TypeKind::Hole;
+    return T->getKind() == TypeKind::Placeholder;
   }
 };
-DEFINE_EMPTY_CAN_TYPE_WRAPPER(HoleType, Type)
+DEFINE_EMPTY_CAN_TYPE_WRAPPER(PlaceholderType, Type)
 
 inline bool TypeBase::isTypeVariableOrMember() {
   if (is<TypeVariableType>())

include/swift/Sema/CSBindings.h

@@ -138,7 +138,7 @@ struct PotentialBinding {
 
   static PotentialBinding forHole(TypeVariableType *typeVar,
                                   ConstraintLocator *locator) {
-    return {HoleType::get(typeVar->getASTContext(), typeVar),
+    return {PlaceholderType::get(typeVar->getASTContext(), typeVar),
             AllowedBindingKind::Exact,
             /*source=*/locator};
   }
@@ -279,9 +279,9 @@ struct PotentialBindings {
   bool isPotentiallyIncomplete() const;
 
   /// If this type variable doesn't have any viable bindings, or
-  /// if there is only one binding and it's a hole type, consider
+  /// if there is only one binding and it's a placeholder type, consider
   /// this type variable to be a hole in a constraint system
-  /// regardless of where hole type originated.
+  /// regardless of where the placeholder type originated.
   bool isHole() const {
     if (isDirectHole())
       return true;
@@ -290,14 +290,14 @@ struct PotentialBindings {
       return false;
 
     const auto &binding = Bindings.front();
-    return binding.BindingType->is<HoleType>();
+    return binding.BindingType->is<PlaceholderType>();
   }
 
   /// Determines whether the only possible binding for this type variable
-  /// would be a hole type. This is different from `isHole` method because
-  /// type variable could also acquire a hole type transitively if one
-  /// of the type variables in its subtype/equivalence chain has been
-  /// bound to a hole type.
+  /// would be a placeholder type. This is different from `isHole` method
+  /// because type variable could also acquire a placeholder type transitively
+  /// if one of the type variables in its subtype/equivalence chain has been
+  /// bound to a placeholder type.
   bool isDirectHole() const;
 
   /// Determine if the bindings only constrain the type variable from above

include/swift/Sema/ConstraintLocator.h

@@ -781,6 +781,20 @@ class LocatorPathElt::ConformanceRequirement final
   }
 };
 
+class LocatorPathElt::PlaceholderType final
+    : public StoredPointerElement<PlaceholderTypeRepr> {
+public:
+  PlaceholderType(PlaceholderTypeRepr *placeholderRepr)
+      : StoredPointerElement(PathElementKind::PlaceholderType,
+                             placeholderRepr) {}
+
+  PlaceholderTypeRepr *getPlaceholderRepr() const { return getStoredPointer(); }
+
+  static bool classof(const LocatorPathElt *elt) {
+    return elt->getKind() == ConstraintLocator::PlaceholderType;
+  }
+};
+
 namespace details {
   template <typename CustomPathElement>
   class PathElement {

include/swift/Sema/ConstraintLocatorPathElts.def

@@ -198,6 +198,9 @@ SIMPLE_LOCATOR_PATH_ELT(UnresolvedMemberChainResult)
 /// The conformance requirement associated with a type.
 CUSTOM_LOCATOR_PATH_ELT(ConformanceRequirement)
 
+/// A source-specified placeholder.
+CUSTOM_LOCATOR_PATH_ELT(PlaceholderType)
+
 #undef LOCATOR_PATH_ELT
 #undef CUSTOM_LOCATOR_PATH_ELT
 #undef SIMPLE_LOCATOR_PATH_ELT

include/swift/Sema/ConstraintSystem.h

@@ -255,7 +255,7 @@ enum TypeVariableOptions {
   /// Whether the type variable can be bound to a non-escaping type or not.
   TVO_CanBindToNoEscape = 0x04,
 
-  /// Whether the type variable can be bound to a hole type or not.
+  /// Whether the type variable can be bound to a hole or not.
   TVO_CanBindToHole = 0x08,
 
   /// Whether a more specific deduction for this type variable implies a
@@ -327,7 +327,7 @@ class TypeVariableType::Implementation {
   /// Whether this type variable can bind to an inout type.
   bool canBindToNoEscape() const { return getRawOptions() & TVO_CanBindToNoEscape; }
 
-  /// Whether this type variable can bind to a hole type.
+  /// Whether this type variable can bind to a hole.
   bool canBindToHole() const { return getRawOptions() & TVO_CanBindToHole; }
 
   /// Whether this type variable prefers a subtype binding over a supertype
@@ -5033,10 +5033,12 @@ class HandlePlaceholderType {
                                  const ConstraintLocatorBuilder &locator)
       : cs(cs), locator(locator) {}
 
-  Type operator()() const {
+  Type operator()(PlaceholderTypeRepr *placeholderRepr) const {
     return cs.createTypeVariable(
-        cs.getConstraintLocator(locator),
-        TVO_CanBindToNoEscape | TVO_PrefersSubtypeBinding | TVO_CanBindToHole);
+        cs.getConstraintLocator(
+            locator, LocatorPathElt::PlaceholderType(placeholderRepr)),
+        TVO_CanBindToNoEscape | TVO_PrefersSubtypeBinding |
+            TVO_CanBindToHole);
   }
 };
 

lib/AST/ASTContext.cpp

@@ -595,8 +595,6 @@ 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)),
@@ -1519,9 +1517,8 @@ bool ASTContext::hadError() const {
 /// Retrieve the arena from which we should allocate storage for a type.
 static AllocationArena getArena(RecursiveTypeProperties properties) {
   bool hasTypeVariable = properties.hasTypeVariable();
-  bool hasHole = properties.hasTypeHole();
-  return hasTypeVariable || hasHole ? AllocationArena::ConstraintSolver
-                                    : AllocationArena::Permanent;
+  return hasTypeVariable ? AllocationArena::ConstraintSolver
+                         : AllocationArena::Permanent;
 }
 
 void ASTContext::addSearchPath(StringRef searchPath, bool isFramework,
@@ -2497,11 +2494,10 @@ Type ErrorType::get(Type originalType) {
   return entry = new (mem) ErrorType(ctx, originalType, properties);
 }
 
-Type HoleType::get(ASTContext &ctx, Originator originator) {
+Type PlaceholderType::get(ASTContext &ctx, Originator originator) {
   assert(originator);
-  auto arena = getArena(RecursiveTypeProperties::HasTypeHole);
-  return new (ctx, arena)
-      HoleType(ctx, originator, RecursiveTypeProperties::HasTypeHole);
+  return new (ctx, AllocationArena::Permanent)
+      PlaceholderType(ctx, originator, RecursiveTypeProperties::HasPlaceholder);
 }
 
 BuiltinIntegerType *BuiltinIntegerType::get(BuiltinIntegerWidth BitWidth,
@@ -2945,7 +2941,7 @@ ReferenceStorageType *ReferenceStorageType::get(Type T,
                                                 ReferenceOwnership ownership,
                                                 const ASTContext &C) {
   assert(!T->hasTypeVariable()); // not meaningful in type-checker
-  assert(!T->hasHole());
+  assert(!T->hasPlaceholder());
   switch (optionalityOf(ownership)) {
   case ReferenceOwnershipOptionality::Disallowed:
     assert(!T->getOptionalObjectType() && "optional type is disallowed");
@@ -3104,7 +3100,7 @@ isFunctionTypeCanonical(ArrayRef<AnyFunctionType::Param> params,
 static RecursiveTypeProperties
 getGenericFunctionRecursiveProperties(ArrayRef<AnyFunctionType::Param> params,
                                       Type result) {
-  static_assert(RecursiveTypeProperties::BitWidth == 13,
+  static_assert(RecursiveTypeProperties::BitWidth == 12,
                 "revisit this if you add new recursive type properties");
   RecursiveTypeProperties properties;
 
@@ -3332,7 +3328,7 @@ GenericFunctionType *GenericFunctionType::get(GenericSignature sig,
                                               ExtInfo info) {
   assert(sig && "no generic signature for generic function type?!");
   assert(!result->hasTypeVariable());
-  assert(!result->hasHole());
+  assert(!result->hasPlaceholder());
 
   llvm::FoldingSetNodeID id;
   GenericFunctionType::Profile(id, sig, params, result, info);
@@ -3678,7 +3674,7 @@ CanSILFunctionType SILFunctionType::get(
   void *mem = ctx.Allocate(bytes, alignof(SILFunctionType));
 
   RecursiveTypeProperties properties;
-  static_assert(RecursiveTypeProperties::BitWidth == 13,
+  static_assert(RecursiveTypeProperties::BitWidth == 12,
                 "revisit this if you add new recursive type properties");
   for (auto &param : params)
     properties |= param.getInterfaceType()->getRecursiveProperties();

lib/AST/ASTDumper.cpp

@@ -3535,20 +3535,19 @@ namespace {
 
     TRIVIAL_TYPE_PRINTER(Unresolved, unresolved)
 
-    TRIVIAL_TYPE_PRINTER(Placeholder, placeholder)
-
-    void visitHoleType(HoleType *T, StringRef label) {
-      printCommon(label, "hole_type");
+    void visitPlaceholderType(PlaceholderType *T, StringRef label) {
+      printCommon(label, "placeholder_type");
       auto originator = T->getOriginator();
       if (auto *typeVar = originator.dyn_cast<TypeVariableType *>()) {
         printRec("type_variable", typeVar);
       } else if (auto *VD = originator.dyn_cast<VarDecl *>()) {
         VD->dumpRef(PrintWithColorRAII(OS, DeclColor).getOS());
       } else if (auto *EE = originator.dyn_cast<ErrorExpr *>()) {
         printFlag("error_expr");
+      } else if (auto *DMT = originator.dyn_cast<DependentMemberType *>()) {
+        printRec("dependent_member_type", DMT);
       } else {
-        printRec("dependent_member_type",
-                 originator.get<DependentMemberType *>());
+        printFlag("placeholder_type_repr");
       }
       PrintWithColorRAII(OS, ParenthesisColor) << ')';
     }

lib/AST/ASTMangler.cpp

@@ -958,15 +958,14 @@ void ASTMangler::appendType(Type type, const ValueDecl *forDecl) {
   TypeBase *tybase = type.getPointer();
   switch (type->getKind()) {
     case TypeKind::TypeVariable:
-    case TypeKind::Hole:
+    case TypeKind::Placeholder:
       llvm_unreachable("mangling type variable");
 
     case TypeKind::Module:
       llvm_unreachable("Cannot mangle module type yet");
 
     case TypeKind::Error:
     case TypeKind::Unresolved:
-    case TypeKind::Placeholder:
       appendOperator("Xe");
       return;
 

lib/AST/ASTPrinter.cpp

@@ -4169,15 +4169,8 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
   }
 
   void visitPlaceholderType(PlaceholderType *T) {
-    if (Options.PrintTypesForDebugging)
-      Printer << "<<placeholdertype>>";
-    else
-      Printer << "_";
-  }
-
-  void visitHoleType(HoleType *T) {
     if (Options.PrintTypesForDebugging) {
-      Printer << "<<hole for ";
+      Printer << "<<placeholder for ";
       auto originator = T->getOriginator();
       if (auto *typeVar = originator.dyn_cast<TypeVariableType *>()) {
         visit(typeVar);
@@ -4186,8 +4179,10 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
         Printer << VD->getName();
       } else if (auto *EE = originator.dyn_cast<ErrorExpr *>()) {
         Printer << "error_expr";
+      } else if (auto *DMT = originator.dyn_cast<DependentMemberType *>()) {
+        visit(DMT);
       } else {
-        visit(originator.get<DependentMemberType *>());
+        Printer << "placeholder_type_repr";
       }
       Printer << ">>";
     } else {