Remove most uses of OptionalTypeKind.

What remains are places where we are conflating optionality with
either nullability or failability.

Author: rudkx

include/swift/AST/ASTContext.h

@@ -90,7 +90,6 @@ namespace swift {
   class PrecedenceGroupDecl;
   class TupleTypeElt;
   class EnumElementDecl;
-  enum OptionalTypeKind : unsigned;
   class ProtocolDecl;
   class SubstitutableType;
   class SourceManager;
@@ -410,18 +409,12 @@ class ASTContext {
   DECL_CLASS *get##NAME##Decl() const;
 #include "swift/AST/KnownStdlibTypes.def"
 
-  /// Retrieve the declaration of Swift.Optional.
-  EnumDecl *getOptionalDecl(OptionalTypeKind kind) const;
-
   /// Retrieve the declaration of Swift.Optional<T>.Some.
   EnumElementDecl *getOptionalSomeDecl() const;
 
   /// Retrieve the declaration of Swift.Optional<T>.None.
   EnumElementDecl *getOptionalNoneDecl() const;
 
-  EnumElementDecl *getOptionalSomeDecl(OptionalTypeKind kind) const;
-  EnumElementDecl *getOptionalNoneDecl(OptionalTypeKind kind) const;
-
   /// Retrieve the declaration of the "pointee" property of a pointer type.
   VarDecl *getPointerPointeePropertyDecl(PointerTypeKind ptrKind) const;
 

include/swift/AST/DiagnosticsSema.def

@@ -613,12 +613,6 @@ ERROR(invalid_redecl,none,"invalid redeclaration of %0", (DeclName))
 NOTE(invalid_redecl_prev,none,
      "%0 previously declared here", (DeclName))
 
-WARNING(deprecated_redecl_by_optionality, none,
-        "invalid redeclaration of %0 which differs only by the kind of optional passed as an inout argument (%1 vs. %2)",
-        (DeclName, Type, Type))
-NOTE(deprecated_redecl_by_optionality_note, none,
-     "overloading by kind of optional is deprecated and will be removed in a future release", ())
-
 ERROR(ambiguous_type_base,none,
       "%0 is ambiguous for type lookup in this context", (Identifier))
 ERROR(invalid_member_type,none,

include/swift/AST/Type.h

@@ -43,7 +43,6 @@ class ModuleDecl;
 class NominalTypeDecl;
 class GenericTypeDecl;
 class NormalProtocolConformance;
-enum OptionalTypeKind : unsigned;
 class ProtocolConformanceRef;
 class ProtocolDecl;
 class ProtocolType;
@@ -389,8 +388,7 @@ class CanType : public Type {
   static bool isExistentialTypeImpl(CanType type);
   static bool isAnyExistentialTypeImpl(CanType type);
   static bool isObjCExistentialTypeImpl(CanType type);
-  static CanType getOptionalObjectTypeImpl(CanType type,
-                                           OptionalTypeKind &kind);
+  static CanType getOptionalObjectTypeImpl(CanType type, bool &isOptional);
   static CanType getReferenceStorageReferentImpl(CanType type);
   static CanType getWithoutSpecifierTypeImpl(CanType type);
 
@@ -458,12 +456,12 @@ class CanType : public Type {
   GenericTypeDecl *getAnyGeneric() const;
 
   CanType getOptionalObjectType() const {
-    OptionalTypeKind kind;
-    return getOptionalObjectTypeImpl(*this, kind);
+    bool isOptional;
+    return getOptionalObjectTypeImpl(*this, isOptional);
   }
 
-  CanType getOptionalObjectType(OptionalTypeKind &kind) const {
-    return getOptionalObjectTypeImpl(*this, kind);
+  CanType getOptionalObjectType(bool &isOptional) const {
+    return getOptionalObjectTypeImpl(*this, isOptional);
   }
 
   CanType getReferenceStorageReferent() const {

include/swift/AST/Types.h

@@ -69,7 +69,6 @@ namespace swift {
   class ModuleDecl;
   class ModuleType;
   class ProtocolConformance;
-  enum OptionalTypeKind : unsigned;
   enum PointerTypeKind : unsigned;
   struct ValueOwnershipKind;
 
@@ -1002,7 +1001,7 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// Return T if this type is Optional<T>; otherwise, return the null
   /// type. Set \p kind to OTK_Optional if it is an optional, OTK_None
   /// otherwise.
-  Type getOptionalObjectType(OptionalTypeKind &kind);
+  Type getOptionalObjectType(bool &isOptional);
 
   // Return type underlying type of a swift_newtype annotated imported struct;
   // otherwise, return the null type.
@@ -4092,16 +4091,6 @@ class OptionalType : public UnarySyntaxSugarType {
   /// Return a uniqued optional type with the specified base type.
   static OptionalType *get(Type baseTy);
 
-  /// Build one of the optional type sugar kinds.
-  ///
-  /// It's a bit unnatural to have this on OptionalType, but we don't
-  /// have an abstract common class, and polluting TypeBase with it
-  /// would be unfortunate.  If we ever make an AnyOptionalType,
-  /// we can move it there.
-  ///
-  /// \param kind - can't be OTK_None
-  static Type get(OptionalTypeKind kind, Type baseTy);
-
   // Implement isa/cast/dyncast/etc.
   static bool classof(const TypeBase *T) {
     return T->getKind() == TypeKind::Optional;

lib/AST/ASTContext.cpp

@@ -152,12 +152,6 @@ struct ASTContext::Implementation {
   /// The declaration of Swift.Optional<T>.None.
   EnumElementDecl *OptionalNoneDecl = nullptr;
 
-  /// The declaration of Swift.ImplicitlyUnwrappedOptional<T>.Some.
-  EnumElementDecl *ImplicitlyUnwrappedOptionalSomeDecl = nullptr;
-
-  /// The declaration of Swift.ImplicitlyUnwrappedOptional<T>.None.
-  EnumElementDecl *ImplicitlyUnwrappedOptionalNoneDecl = nullptr;
-  
   /// The declaration of Swift.UnsafeMutableRawPointer.memory.
   VarDecl *UnsafeMutableRawPointerMemoryDecl = nullptr;
 
@@ -644,43 +638,6 @@ ProtocolDecl *ASTContext::getErrorDecl() const {
   return getProtocol(KnownProtocolKind::Error);
 }
 
-EnumDecl *ASTContext::getOptionalDecl(OptionalTypeKind kind) const {
-  switch (kind) {
-  case OTK_None:
-    llvm_unreachable("not optional");
-  case OTK_ImplicitlyUnwrappedOptional:
-    llvm_unreachable("Should no longer have IUOs");
-  case OTK_Optional:
-    return getOptionalDecl();
-  }
-
-  llvm_unreachable("Unhandled OptionalTypeKind in switch.");
-}
-
-EnumElementDecl *ASTContext::getOptionalSomeDecl(OptionalTypeKind kind) const {
-  switch (kind) {
-  case OTK_Optional:
-    return getOptionalSomeDecl();
-  case OTK_ImplicitlyUnwrappedOptional:
-    llvm_unreachable("Should not have IUOs.");
-  case OTK_None:
-    llvm_unreachable("getting Some decl for non-optional type?");
-  }
-  llvm_unreachable("bad OTK");
-}
-
-EnumElementDecl *ASTContext::getOptionalNoneDecl(OptionalTypeKind kind) const {
-  switch (kind) {
-  case OTK_Optional:
-    return getOptionalNoneDecl();
-  case OTK_ImplicitlyUnwrappedOptional:
-    llvm_unreachable("Should not have IUOs.");
-  case OTK_None:
-    llvm_unreachable("getting None decl for non-optional type?");
-  }
-  llvm_unreachable("bad OTK");
-}
-
 EnumElementDecl *ASTContext::getOptionalSomeDecl() const {
   if (!Impl.OptionalSomeDecl)
     Impl.OptionalSomeDecl = getOptionalDecl()->getUniqueElement(/*hasVal*/true);
@@ -4025,18 +3982,6 @@ DictionaryType *DictionaryType::get(Type keyType, Type valueType) {
                                                properties);
 }
 
-Type OptionalType::get(OptionalTypeKind which, Type valueType) {
-  switch (which) {
-  // It wouldn't be unreasonable for this method to just ignore
-  // OTK_None if we made code more convenient to write.
-  case OTK_None: llvm_unreachable("building a non-optional type!");
-  case OTK_Optional: return OptionalType::get(valueType);
-  case OTK_ImplicitlyUnwrappedOptional:
-    llvm_unreachable("Should no longer have IUOs");
-  }
-  llvm_unreachable("bad optional type kind");
-}
-
 OptionalType *OptionalType::get(Type base) {
   auto properties = base->getRecursiveProperties();
   auto arena = getArena(properties);

lib/AST/ASTVerifier.cpp

@@ -2687,12 +2687,11 @@ class Verifier : public ASTWalker {
       if (!CD->isInvalid() &&
           CD->getDeclContext()->getDeclaredInterfaceType()->getAnyNominal() !=
               Ctx.getOptionalDecl()) {
-        OptionalTypeKind resultOptionality = OTK_None;
-        CD->getResultInterfaceType()->getOptionalObjectType(resultOptionality);
-        auto declOptionality = CD->getFailability();
+        bool resultIsOptional;
+        CD->getResultInterfaceType()->getOptionalObjectType(resultIsOptional);
+        auto declIsOptional = CD->getFailability() != OTK_None;
 
-        if ((resultOptionality != OTK_None || declOptionality != OTK_None) &&
-            (resultOptionality == OTK_None || declOptionality == OTK_None)) {
+        if (resultIsOptional != declIsOptional) {
           Out << "Initializer has result optionality/failability mismatch\n";
           CD->dump(llvm::errs());
           abort();
@@ -2701,13 +2700,11 @@ class Verifier : public ASTWalker {
         // Also check the interface type.
         if (auto genericFn 
               = CD->getInterfaceType()->getAs<GenericFunctionType>()) {
-          resultOptionality = OTK_None;
           genericFn->getResult()
               ->castTo<AnyFunctionType>()
               ->getResult()
-              ->getOptionalObjectType(resultOptionality);
-          if ((resultOptionality != OTK_None || declOptionality != OTK_None) &&
-              (resultOptionality == OTK_None || declOptionality == OTK_None)) {
+              ->getOptionalObjectType(resultIsOptional);
+          if (resultIsOptional != declIsOptional) {
             Out << "Initializer has result optionality/failability mismatch\n";
             CD->dump(llvm::errs());
             abort();

lib/AST/Type.cpp

@@ -439,10 +439,9 @@ static bool isLegalSILType(CanType type) {
     return true;
   }
 
-  // Optionals are legal if their object type is legal and they're Optional.
-  OptionalTypeKind optKind;
-  if (auto objectType = type.getOptionalObjectType(optKind)) {
-    return (optKind == OTK_Optional && isLegalSILType(objectType));
+  // Optionals are legal if their object type is legal.
+  if (auto objectType = type.getOptionalObjectType()) {
+    return isLegalSILType(objectType);
   }
 
   // Reference storage types are legal if their object type is legal.
@@ -502,26 +501,25 @@ Type TypeBase::getOptionalObjectType() {
   return Type();
 }
 
-Type TypeBase::getOptionalObjectType(OptionalTypeKind &kind) {
+Type TypeBase::getOptionalObjectType(bool &isOptional) {
   if (auto boundTy = getAs<BoundGenericEnumType>()) {
     if (boundTy->getDecl()->isOptionalDecl()) {
-      kind = OTK_Optional;
+      isOptional = true;
       return boundTy->getGenericArgs()[0];
     }
   }
-  kind = OTK_None;
+  isOptional = false;
   return Type();
 }
 
-CanType CanType::getOptionalObjectTypeImpl(CanType type,
-                                           OptionalTypeKind &kind) {
+CanType CanType::getOptionalObjectTypeImpl(CanType type, bool &isOptional) {
   if (auto boundTy = dyn_cast<BoundGenericEnumType>(type)) {
     if (boundTy->getDecl()->isOptionalDecl()) {
-      kind = OTK_Optional;
+      isOptional = true;
       return boundTy.getGenericArgs()[0];
     }
   }
-  kind = OTK_None;
+  isOptional = false;
   return CanType();
 }
 
@@ -684,13 +682,10 @@ Type TypeBase::getWithoutImmediateLabel() {
 Type TypeBase::replaceCovariantResultType(Type newResultType,
                                           unsigned uncurryLevel) {
   if (uncurryLevel == 0) {
-    OptionalTypeKind resultOTK;
-    if (auto objectType = getOptionalObjectType(resultOTK)) {
+    if (auto objectType = getOptionalObjectType()) {
       assert(!newResultType->getOptionalObjectType());
       return OptionalType::get(
-          resultOTK,
-          objectType->replaceCovariantResultType(
-              newResultType, uncurryLevel));
+          objectType->replaceCovariantResultType(newResultType, uncurryLevel));
     }
 
     return newResultType;

lib/AST/TypeJoinMeet.cpp

@@ -67,8 +67,7 @@ struct TypeJoin : CanTypeVisitor<TypeJoin, CanType> {
 
     // Until we handle all the combinations of joins, we need to make
     // sure we visit the optional side.
-    OptionalTypeKind otk;
-    if (second->getOptionalObjectType(otk))
+    if (second->getOptionalObjectType())
       return TypeJoin(first).visit(second);
 
     return TypeJoin(second).visit(first);
@@ -160,12 +159,17 @@ CanType TypeJoin::visitBoundGenericEnumType(CanType second) {
   if (First->getKind() != second->getKind())
     return First->getASTContext().TheAnyType;
 
-  OptionalTypeKind otk1, otk2;
-  auto firstObject = First->getOptionalObjectType(otk1);
-  auto secondObject = second->getOptionalObjectType(otk2);
-  if (otk1 == OTK_Optional || otk2 == OTK_Optional) {
-    auto canFirst = firstObject->getCanonicalType();
-    auto canSecond = secondObject->getCanonicalType();
+  bool firstIsOptional, secondIsOptional;
+  auto firstObject = First->getOptionalObjectType(firstIsOptional);
+  auto secondObject = second->getOptionalObjectType(secondIsOptional);
+  if (firstIsOptional || secondIsOptional) {
+    CanType canFirst;
+    CanType canSecond;
+
+    if (firstObject)
+      canFirst = firstObject->getCanonicalType();
+    if (secondObject)
+      canSecond = secondObject->getCanonicalType();
 
     // Compute the join of the unwrapped type. If there is none, we're done.
     auto unwrappedJoin =

lib/ClangImporter/ImportDecl.cpp

@@ -6106,18 +6106,21 @@ ConstructorDecl *SwiftDeclConverter::importConstructor(
 
   // Determine the failability of this initializer.
   auto oldFnType = type->castTo<AnyFunctionType>();
-  OptionalTypeKind failability;
-  (void)oldFnType->getResult()->getOptionalObjectType(failability);
+  bool resultIsOptional;
+  (void)oldFnType->getResult()->getOptionalObjectType(resultIsOptional);
 
   // Update the failability appropriately based on the imported method type.
-  if (importedType.isImplicitlyUnwrapped()) {
-    assert(failability != OTK_None);
-    failability = OTK_ImplicitlyUnwrappedOptional;
+  assert(resultIsOptional || !importedType.isImplicitlyUnwrapped());
+  OptionalTypeKind failability = OTK_None;
+  if (resultIsOptional) {
+    failability = OTK_Optional;
+    if (importedType.isImplicitlyUnwrapped())
+      failability = OTK_ImplicitlyUnwrappedOptional;
   }
 
   // Rebuild the function type with the appropriate result type;
   Type resultTy = selfTy;
-  if (failability != OTK_None)
+  if (resultIsOptional)
     resultTy = OptionalType::get(resultTy);
 
   type = FunctionType::get(oldFnType->getInput(), resultTy,

lib/ClangImporter/ImportType.cpp

@@ -1238,8 +1238,8 @@ static ImportedType adjustTypeForConcreteImport(
     if (!elementType || PTK != PTK_UnsafeMutablePointer)
       return Type();
 
-    OptionalTypeKind OTK;
-    auto insideOptionalType = elementType->getOptionalObjectType(OTK);
+    bool isOptional;
+    auto insideOptionalType = elementType->getOptionalObjectType(isOptional);
     if (!insideOptionalType)
       insideOptionalType = elementType;
 
@@ -1255,10 +1255,8 @@ static ImportedType adjustTypeForConcreteImport(
            "signature of Unmanaged has changed");
 
     auto resultTy = boundGenericTy->getGenericArgs().front();
-    if (OTK != OTK_None) {
-      assert(OTK != OTK_ImplicitlyUnwrappedOptional);
+    if (isOptional)
       resultTy = OptionalType::get(resultTy);
-    }
 
     StringRef pointerName;
     if (importKind == ImportTypeKind::CFRetainedOutParameter)
@@ -1509,8 +1507,7 @@ ImportedType ClangImporter::Implementation::importPropertyType(
 /// Apply the @noescape attribute
 static Type applyNoEscape(Type type) {
   // Recurse into optional types.
-  OptionalTypeKind optKind;
-  if (Type objectType = type->getOptionalObjectType(optKind)) {
+  if (Type objectType = type->getOptionalObjectType()) {
     return OptionalType::get(applyNoEscape(objectType));
   }
 
@@ -1951,8 +1948,8 @@ ImportedType ClangImporter::Implementation::importMethodType(
       clangDecl->getMethodFamily() == clang::OMF_performSelector) {
     // performSelector methods that return 'id' should be imported into Swift
     // as returning Unmanaged<AnyObject>.
-    Type nonOptionalTy =
-        swiftResultTy->getOptionalObjectType(OptionalityOfReturn);
+    bool resultIsOptional;
+    Type nonOptionalTy = swiftResultTy->getOptionalObjectType(resultIsOptional);
     if (!nonOptionalTy)
       nonOptionalTy = swiftResultTy;
 
@@ -1962,7 +1959,7 @@ ImportedType ClangImporter::Implementation::importMethodType(
 
     if (nonOptionalTy->isAnyClassReferenceType()) {
       swiftResultTy = getUnmanagedType(*this, nonOptionalTy);
-      if (OptionalityOfReturn != OTK_None)
+      if (resultIsOptional)
         swiftResultTy = OptionalType::get(swiftResultTy);
     }
   }