[AST] Allow hole types to originate from declarations

Associating holes directly with declarations is useful in
cases when declarations are invalid e.g. directly `ErrorType`
or have error types inside.

Author: xedin

include/swift/AST/Types.h

@@ -5736,19 +5736,19 @@ DEFINE_EMPTY_CAN_TYPE_WRAPPER(TypeVariableType, 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 OriginatorType =
-      llvm::PointerUnion<TypeVariableType *, DependentMemberType *>;
+  using Originator = llvm::PointerUnion<TypeVariableType *,
+                                        DependentMemberType *, VarDecl *>;
 
-  OriginatorType Originator;
+  Originator O;
 
-  HoleType(ASTContext &C, OriginatorType originator,
+  HoleType(ASTContext &C, Originator originator,
            RecursiveTypeProperties properties)
-      : TypeBase(TypeKind::Hole, &C, properties), Originator(originator) {}
+      : TypeBase(TypeKind::Hole, &C, properties), O(originator) {}
 
 public:
-  static Type get(ASTContext &ctx, OriginatorType originatorType);
+  static Type get(ASTContext &ctx, Originator originator);
 
-  OriginatorType getOriginatorType() const { return Originator; }
+  Originator getOriginator() const { return O; }
 
   static bool classof(const TypeBase *T) {
     return T->getKind() == TypeKind::Hole;

lib/AST/ASTContext.cpp

@@ -2400,13 +2400,9 @@ Type ErrorType::get(Type originalType) {
   return entry = new (mem) ErrorType(ctx, originalType, properties);
 }
 
-Type HoleType::get(ASTContext &ctx, OriginatorType originator) {
+Type HoleType::get(ASTContext &ctx, Originator originator) {
   assert(originator);
-  auto properties = reinterpret_cast<TypeBase *>(originator.getOpaqueValue())
-                        ->getRecursiveProperties();
-  properties |= RecursiveTypeProperties::HasTypeHole;
-
-  auto arena = getArena(properties);
+  auto arena = getArena(RecursiveTypeProperties::HasTypeHole);
   return new (ctx, arena)
       HoleType(ctx, originator, RecursiveTypeProperties::HasTypeHole);
 }

lib/AST/ASTDumper.cpp

@@ -3512,12 +3512,14 @@ namespace {
 
     void visitHoleType(HoleType *T, StringRef label) {
       printCommon(label, "hole_type");
-      auto originatorTy = T->getOriginatorType();
-      if (auto *typeVar = originatorTy.dyn_cast<TypeVariableType *>()) {
+      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 {
         printRec("dependent_member_type",
-                 originatorTy.get<DependentMemberType *>());
+                 originator.get<DependentMemberType *>());
       }
       PrintWithColorRAII(OS, ParenthesisColor) << ')';
     }

lib/AST/ASTPrinter.cpp

@@ -3822,8 +3822,15 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
   void visitHoleType(HoleType *T) {
     if (Options.PrintTypesForDebugging) {
       Printer << "<<hole for ";
-      auto originatorTy = T->getOriginatorType();
-      visit(Type(reinterpret_cast<TypeBase *>(originatorTy.getOpaqueValue())));
+      auto originator = T->getOriginator();
+      if (auto *typeVar = originator.dyn_cast<TypeVariableType *>()) {
+        visit(typeVar);
+      } else if (auto *VD = originator.dyn_cast<VarDecl *>()) {
+        Printer << "decl = ";
+        Printer << VD->getName();
+      } else {
+        visit(originator.get<DependentMemberType *>());
+      }
       Printer << ">>";
     } else {
       Printer << "<<hole>>";

lib/Sema/CSSimplify.cpp

@@ -7016,7 +7016,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyMemberConstraint(
       // type but a hole.
       auto shouldRecordFixForHole = [&](HoleType *baseType) {
         auto *originator =
-            baseType->getOriginatorType().dyn_cast<TypeVariableType *>();
+            baseType->getOriginator().dyn_cast<TypeVariableType *>();
 
         if (!originator)
           return false;

lib/Sema/TypeCheckCodeCompletion.cpp

@@ -1012,7 +1012,7 @@ sawSolution(const constraints::Solution &S) {
       return S.simplifyType(completionTy.transform([&](Type type) {
         if (auto *hole = type->getAs<HoleType>()) {
           if (auto *typeVar =
-                  hole->getOriginatorType().dyn_cast<TypeVariableType *>()) {
+                  hole->getOriginator().dyn_cast<TypeVariableType *>()) {
             if (auto *GP = typeVar->getImpl().getGenericParameter()) {
               // Code completion depends on generic parameter type being
               // represented in terms of `ArchetypeType` since it's easy