[AST] Remove UnresolvedType

We have now removed all uses of this type.

Author: hamishknight

include/swift/AST/ASTContext.h

@@ -1044,7 +1044,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 TheEmptyTupleType;        /// This is '()', aka Void
   const CanType TheEmptyPackType;
   const CanType TheAnyType;               /// This is 'Any', the empty protocol composition

include/swift/AST/TypeMatcher.h

@@ -117,12 +117,6 @@ class TypeMatcher {
 #define SINGLETON_TYPE(SHORT_ID, ID) TRIVIAL_CASE(ID##Type)
 #include "swift/AST/TypeNodes.def"
 
-    bool visitUnresolvedType(CanUnresolvedType firstType, Type secondType,
-                             Type sugaredFirstType) {
-      // Unresolved types never match.
-      return mismatch(firstType.getPointer(), secondType, sugaredFirstType);
-    }
-
     bool visitTupleType(CanTupleType firstTuple, Type secondType,
                         Type sugaredFirstType) {
       if (auto secondTuple = secondType->getAs<TupleType>()) {

include/swift/AST/TypeNodes.def

@@ -123,7 +123,6 @@
 #if !defined(SINGLETON_TYPE)
 
 TYPE(Error, Type)
-UNCHECKED_TYPE(Unresolved, Type)
 UNCHECKED_TYPE(Placeholder, Type)
 ABSTRACT_TYPE(Builtin, Type)
   ABSTRACT_TYPE(AnyBuiltinInteger, BuiltinType)

include/swift/AST/TypeTransform.h

@@ -109,7 +109,6 @@ case TypeKind::Id:
 #define TYPE(Id, Parent)
 #include "swift/AST/TypeNodes.def"
     case TypeKind::Error:
-    case TypeKind::Unresolved:
     case TypeKind::TypeVariable:
     case TypeKind::Placeholder:
     case TypeKind::SILToken:

include/swift/AST/Types.h

@@ -141,61 +141,58 @@ class RecursiveTypeProperties {
     /// This type expression contains a GenericTypeParamType.
     HasTypeParameter     = 0x04,
 
-    /// This type expression contains an UnresolvedType.
-    HasUnresolvedType    = 0x08,
-
     /// Whether this type expression contains an unbound generic type.
-    HasUnboundGeneric    = 0x10,
+    HasUnboundGeneric    = 0x08,
 
     /// This type expression contains an LValueType other than as a
     /// function input, and can be loaded to convert to an rvalue.
-    IsLValue             = 0x20,
+    IsLValue             = 0x10,
 
     /// This type expression contains an opened existential ArchetypeType.
-    HasOpenedExistential = 0x40,
+    HasOpenedExistential = 0x20,
 
     /// This type expression contains a DynamicSelf type.
-    HasDynamicSelf       = 0x80,
+    HasDynamicSelf       = 0x40,
 
     /// This type contains an Error type.
-    HasError             = 0x100,
+    HasError             = 0x80,
 
     /// This type contains an Error type without an underlying original type.
-    HasBareError         = 0x200,
+    HasBareError         = 0x100,
 
     /// This type contains a DependentMemberType.
-    HasDependentMember   = 0x400,
+    HasDependentMember   = 0x200,
 
     /// This type contains an OpaqueTypeArchetype.
-    HasOpaqueArchetype   = 0x800,
+    HasOpaqueArchetype   = 0x400,
 
     /// This type contains a type placeholder.
-    HasPlaceholder       = 0x1000,
+    HasPlaceholder       = 0x800,
 
     /// This type contains a generic type parameter that is declared as a
     /// parameter pack.
-    HasParameterPack = 0x2000,
+    HasParameterPack = 0x1000,
 
     /// This type contains a parameterized existential type \c any P<T>.
-    HasParameterizedExistential = 0x4000,
+    HasParameterizedExistential = 0x2000,
 
     /// This type contains an ElementArchetypeType.
-    HasElementArchetype = 0x8000,
+    HasElementArchetype = 0x4000,
 
     /// Whether the type is allocated in the constraint solver arena. This can
     /// differ from \c HasTypeVariable for types such as placeholders, which do
     /// not have type variables, but we still want to allocate in the solver if
     /// they have a type variable originator.
-    SolverAllocated = 0x10000,
+    SolverAllocated = 0x8000,
 
     /// Contains a PackType.
-    HasPack = 0x20000,
+    HasPack = 0x10000,
 
     /// Contains a PackArchetypeType. Also implies HasPrimaryArchetype.
-    HasPackArchetype = 0x40000,
+    HasPackArchetype = 0x20000,
 
     /// Whether this type contains an unsafe type.
-    IsUnsafe = 0x080000,
+    IsUnsafe = 0x040000,
 
     Last_Property = IsUnsafe
   };
@@ -228,9 +225,6 @@ class RecursiveTypeProperties {
   /// Does a type with these properties have a type parameter somewhere in it?
   bool hasTypeParameter() const { return Bits & HasTypeParameter; }
 
-  /// Does a type with these properties have an unresolved type somewhere in it?
-  bool hasUnresolvedType() const { return Bits & HasUnresolvedType; }
-
   /// Is a type with these properties an lvalue?
   bool isLValue() const { return Bits & IsLValue; }
 
@@ -756,11 +750,6 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// member root in a type variable.
   bool isTypeVariableOrMember();
 
-  /// Determine whether this type involves a UnresolvedType.
-  bool hasUnresolvedType() const {
-    return getRecursiveProperties().hasUnresolvedType();
-  }
-
   /// Determine whether this type involves a \c PlaceholderType.
   bool hasPlaceholder() const {
     return getRecursiveProperties().hasPlaceholder();
@@ -1712,25 +1701,6 @@ class ErrorType final : public TypeBase {
   }
 };
 DEFINE_EMPTY_CAN_TYPE_WRAPPER(ErrorType, Type)
-
-/// UnresolvedType - This represents a type variable that cannot be resolved to
-/// a concrete type because the expression is ambiguous.  This is produced when
-/// parsing expressions and producing diagnostics.  Any instance of this should
-/// cause the entire expression to be ambiguously typed.
-class UnresolvedType : public TypeBase {
-  friend class ASTContext;
-  // The Unresolved type is always canonical.
-  UnresolvedType(ASTContext &C)
-    : TypeBase(TypeKind::Unresolved, &C,
-       RecursiveTypeProperties(RecursiveTypeProperties::HasUnresolvedType)) { }
-public:
-  // Implement isa/cast/dyncast/etc.
-  static bool classof(const TypeBase *T) {
-    return T->getKind() == TypeKind::Unresolved;
-  }
-};
-DEFINE_EMPTY_CAN_TYPE_WRAPPER(UnresolvedType, Type)
-
 
 /// BuiltinType - An abstract class for all the builtin types.
 class BuiltinType : public TypeBase {

include/swift/IDE/TypeCheckCompletionCallback.h

@@ -92,7 +92,7 @@ struct WithSolutionSpecificVarTypesRAII {
       } else {
         RestoreVarTypes[var] = Type();
       }
-      if (!ty->hasArchetype() && !ty->hasUnresolvedType()) {
+      if (!ty->hasArchetype()) {
         setInterfaceType(const_cast<VarDecl *>(var), ty);
       } else {
         setInterfaceType(const_cast<VarDecl *>(var), ErrorType::get(ty));

lib/AST/ASTContext.cpp

@@ -5856,7 +5856,7 @@ ProtocolConformanceRef ProtocolConformanceRef::forAbstract(
   case TypeKind::GenericTypeParam:
   case TypeKind::TypeVariable:
   case TypeKind::DependentMember:
-  case TypeKind::Unresolved:
+  case TypeKind::Error:
   case TypeKind::Placeholder:
   case TypeKind::PrimaryArchetype:
   case TypeKind::PackArchetype:

lib/AST/ASTDumper.cpp

@@ -6062,8 +6062,6 @@ namespace {
       printFoot();
     }
 
-    TRIVIAL_TYPE_PRINTER(Unresolved, unresolved)
-
     void visitPlaceholderType(PlaceholderType *T, Label label) {
       printCommon("placeholder_type", label);
       auto originator = T->getOriginator();

lib/AST/ASTMangler.cpp

@@ -1417,7 +1417,6 @@ void ASTMangler::appendType(Type type, GenericSignature sig,
       llvm_unreachable("Cannot mangle module type yet");
 
     case TypeKind::Error:
-    case TypeKind::Unresolved:
     case TypeKind::Placeholder:
       appendOperator("Xe");
       return;

lib/AST/ASTPrinter.cpp

@@ -6204,14 +6204,6 @@ class TypePrinter : public TypeVisitor<TypePrinter, void, NonRecursivePrintOptio
     }
   }
 
-  void visitUnresolvedType(UnresolvedType *T,
-                           NonRecursivePrintOptions nrOptions) {
-    if (Options.PrintTypesForDebugging)
-      Printer << "<<unresolvedtype>>";
-    else
-      Printer << "_";
-  }
-
   void visitErrorUnionType(ErrorUnionType *T,
                            NonRecursivePrintOptions nrOptions) {
     Printer << "error_union(";