Make ImplicitlyUnwrappedOptional<T> an unavailable typealias.

include/swift/AST/ASTContext.h

@@ -410,7 +410,7 @@ class ASTContext {
   DECL_CLASS *get##NAME##Decl() const;
 #include "swift/AST/KnownStdlibTypes.def"
 
-  /// Retrieve the declaration of Swift.Optional or ImplicitlyUnwrappedOptional.
+  /// Retrieve the declaration of Swift.Optional.
   EnumDecl *getOptionalDecl(OptionalTypeKind kind) const;
 
   /// Retrieve the declaration of Swift.Optional<T>.Some.
@@ -419,12 +419,6 @@ class ASTContext {
   /// Retrieve the declaration of Swift.Optional<T>.None.
   EnumElementDecl *getOptionalNoneDecl() const;
 
-  /// Retrieve the declaration of Swift.ImplicitlyUnwrappedOptional<T>.Some.
-  EnumElementDecl *getImplicitlyUnwrappedOptionalSomeDecl() const;
-
-  /// Retrieve the declaration of Swift.ImplicitlyUnwrappedOptional<T>.None.
-  EnumElementDecl *getImplicitlyUnwrappedOptionalNoneDecl() const;
-
   EnumElementDecl *getOptionalSomeDecl(OptionalTypeKind kind) const;
   EnumElementDecl *getOptionalNoneDecl(OptionalTypeKind kind) const;
 

include/swift/AST/DiagnosticsSema.def

@@ -1056,7 +1056,7 @@ ERROR(iboutlet_non_optional,none,
 NOTE(note_make_optional,none,
       "add '?' to form the optional type %0", (Type))
 NOTE(note_make_implicitly_unwrapped_optional,none,
-      "add '!' to form the implicitly unwrapped optional type %0", (Type))
+      "add '!' to form an implicitly unwrapped optional", ())
 
 ERROR(invalid_ibdesignable_extension,none,
       "@IBDesignable can only be applied to classes and extensions "
@@ -3129,32 +3129,11 @@ ERROR(tuple_single_element,none,
 ERROR(tuple_ellipsis,none,
       "cannot create a variadic tuple", ())
 
-WARNING(implicitly_unwrapped_optional_spelling_deprecated,none,
-        "the spelling 'ImplicitlyUnwrappedOptional' is deprecated; use an explicit type followed by '!'", ())
-
-WARNING(implicitly_unwrapped_optional_spelling_deprecated_with_fixit,none,
-        "the spelling 'ImplicitlyUnwrappedOptional' is deprecated; use '!' after the type name", ())
-
-WARNING(implicitly_unwrapped_optional_spelling_suggest_optional,none,
-        "using 'ImplicitlyUnwrappedOptional' in this location is deprecated and will be removed in a future release; consider changing this to 'Optional' instead", ())
-
-WARNING(implicitly_unwrapped_optional_in_illegal_position_suggest_optional,none,
-        "using '!' in this location is deprecated and will be removed in a future release; consider changing this to '?' instead", ())
-
-ERROR(implicitly_unwrapped_optional_spelling_error,none,
-        "the spelling 'ImplicitlyUnwrappedOptional' is unsupported; use an explicit type followed by '!'", ())
-
-ERROR(implicitly_unwrapped_optional_spelling_error_with_bang_fixit,none,
-        "the spelling 'ImplicitlyUnwrappedOptional' is unsupported; use '!' after the type name", ())
-
-ERROR(implicitly_unwrapped_optional_spelling_error_with_optional_fixit,none,
-        "the spelling 'ImplicitlyUnwrappedOptional' is unsupported; use 'Optional' instead", ())
-
-ERROR(implicitly_unwrapped_optional_spelling_in_illegal_position,none,
-        "'ImplicitlyUnwrappedOptional' is not allowed here; perhaps 'Optional' was intended?", ())
+WARNING(implicitly_unwrapped_optional_in_illegal_position_interpreted_as_optional,none,
+        "using '!' is not allowed here; treating this as '?' instead", ())
 
 ERROR(implicitly_unwrapped_optional_in_illegal_position,none,
-        "'!' is not allowed here; perhaps '?' was intended?", ())
+        "using '!' is not allowed here; perhaps '?' was intended?", ())
 
 // Ownership
 ERROR(invalid_ownership_type,none,

include/swift/AST/KnownIdentifiers.def

@@ -57,7 +57,6 @@ IDENTIFIER(forKey)
 IDENTIFIER(from)
 IDENTIFIER(fromRaw)
 IDENTIFIER(hashValue)
-IDENTIFIER(ImplicitlyUnwrappedOptional)
 IDENTIFIER(init)
 IDENTIFIER(initialize)
 IDENTIFIER(initStorage)

include/swift/AST/KnownStdlibTypes.def

@@ -58,7 +58,6 @@ KNOWN_STDLIB_TYPE_DECL(WritableKeyPath, NominalTypeDecl, 2)
 KNOWN_STDLIB_TYPE_DECL(ReferenceWritableKeyPath, NominalTypeDecl, 2)
 
 KNOWN_STDLIB_TYPE_DECL(Optional, EnumDecl, 1)
-KNOWN_STDLIB_TYPE_DECL(ImplicitlyUnwrappedOptional, EnumDecl, 1)
 
 KNOWN_STDLIB_TYPE_DECL(OptionSet, NominalTypeDecl, 1)
 

include/swift/AST/Types.h

@@ -4115,7 +4115,8 @@ class ImplicitlyUnwrappedOptionalType : public UnarySyntaxSugarType {
                         RecursiveTypeProperties properties)
     : UnarySyntaxSugarType(TypeKind::ImplicitlyUnwrappedOptional, ctx, base,
                            properties) {
-    //llvm_unreachable("ImplicitlyUnwrappedOptionalType::ImplicitlyUnwrappedOptionalType");
+    llvm_unreachable(
+        "ImplicitlyUnwrappedOptionalType::ImplicitlyUnwrappedOptionalType");
   }
 
 public:

include/swift/Serialization/ModuleFormat.h

@@ -54,7 +54,7 @@ const uint16_t VERSION_MAJOR = 0;
 /// in source control, you should also update the comment to briefly
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
-const uint16_t VERSION_MINOR = 393; // SILLinkage::PublicNonABI
+const uint16_t VERSION_MINOR = 394; // Remove IUO serialization and decl
 
 using DeclIDField = BCFixed<31>;
 
@@ -790,8 +790,6 @@ namespace decls_block {
 
   using ArraySliceTypeLayout = SyntaxSugarTypeLayout<ARRAY_SLICE_TYPE>;
   using OptionalTypeLayout = SyntaxSugarTypeLayout<OPTIONAL_TYPE>;
-  using ImplicitlyUnwrappedOptionalTypeLayout =
-    SyntaxSugarTypeLayout<UNCHECKED_OPTIONAL_TYPE>;
 
   using DictionaryTypeLayout = BCRecordLayout<
     DICTIONARY_TYPE,

lib/AST/ASTContext.cpp

@@ -650,7 +650,7 @@ EnumDecl *ASTContext::getOptionalDecl(OptionalTypeKind kind) const {
   case OTK_None:
     llvm_unreachable("not optional");
   case OTK_ImplicitlyUnwrappedOptional:
-    return getImplicitlyUnwrappedOptionalDecl();
+    llvm_unreachable("Should no longer have IUOs");
   case OTK_Optional:
     return getOptionalDecl();
   }
@@ -663,7 +663,7 @@ EnumElementDecl *ASTContext::getOptionalSomeDecl(OptionalTypeKind kind) const {
   case OTK_Optional:
     return getOptionalSomeDecl();
   case OTK_ImplicitlyUnwrappedOptional:
-    return getImplicitlyUnwrappedOptionalSomeDecl();
+    llvm_unreachable("Should not have IUOs.");
   case OTK_None:
     llvm_unreachable("getting Some decl for non-optional type?");
   }
@@ -675,7 +675,7 @@ EnumElementDecl *ASTContext::getOptionalNoneDecl(OptionalTypeKind kind) const {
   case OTK_Optional:
     return getOptionalNoneDecl();
   case OTK_ImplicitlyUnwrappedOptional:
-    return getImplicitlyUnwrappedOptionalNoneDecl();
+    llvm_unreachable("Should not have IUOs.");
   case OTK_None:
     llvm_unreachable("getting None decl for non-optional type?");
   }
@@ -694,20 +694,6 @@ EnumElementDecl *ASTContext::getOptionalNoneDecl() const {
   return Impl.OptionalNoneDecl;
 }
 
-EnumElementDecl *ASTContext::getImplicitlyUnwrappedOptionalSomeDecl() const {
-  if (!Impl.ImplicitlyUnwrappedOptionalSomeDecl)
-    Impl.ImplicitlyUnwrappedOptionalSomeDecl =
-      getImplicitlyUnwrappedOptionalDecl()->getUniqueElement(/*hasVal*/true);
-  return Impl.ImplicitlyUnwrappedOptionalSomeDecl;
-}
-
-EnumElementDecl *ASTContext::getImplicitlyUnwrappedOptionalNoneDecl() const {
-  if (!Impl.ImplicitlyUnwrappedOptionalNoneDecl)
-    Impl.ImplicitlyUnwrappedOptionalNoneDecl =
-      getImplicitlyUnwrappedOptionalDecl()->getUniqueElement(/*hasVal*/false);
-  return Impl.ImplicitlyUnwrappedOptionalNoneDecl;
-}
-
 static VarDecl *getPointeeProperty(VarDecl *&cache,
                            NominalTypeDecl *(ASTContext::*getNominal)() const,
                                   const ASTContext &ctx) {

lib/AST/ASTMangler.cpp

@@ -756,11 +756,7 @@ void ASTMangler::appendType(Type type) {
       return appendSugaredType<SyntaxSugarType>(type);
 
     case TypeKind::ImplicitlyUnwrappedOptional: {
-      assert(DWARFMangling && "sugared types are only legal for the debugger");
-      auto *IUO = cast<ImplicitlyUnwrappedOptionalType>(tybase);
-      auto implDecl = tybase->getASTContext().getImplicitlyUnwrappedOptionalDecl();
-      auto GenTy = BoundGenericType::get(implDecl, Type(), IUO->getBaseType());
-      return appendType(GenTy);
+      llvm_unreachable("Should no longer have IUOs");
     }
 
     case TypeKind::ExistentialMetatype: {

lib/AST/ASTPrinter.cpp

@@ -3337,11 +3337,6 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
         Printer << "?";
         return;
       }
-      if (NT == Ctx.getImplicitlyUnwrappedOptionalDecl()) {
-        printWithParensIfNotSimple(T->getGenericArgs()[0]);
-        Printer << "!";
-        return;
-      }
     }
     if (auto ParentType = T->getParent()) {
       visit(ParentType);

lib/AST/ASTVerifier.cpp

@@ -2684,11 +2684,9 @@ class Verifier : public ASTWalker {
 
       // Verify that the optionality of the result type of the
       // initializer matches the failability of the initializer.
-      if (!CD->isInvalid() && 
-          CD->getDeclContext()->getDeclaredInterfaceType()->getAnyNominal() 
-            != Ctx.getOptionalDecl() &&
-          CD->getDeclContext()->getDeclaredInterfaceType()->getAnyNominal() 
-            != Ctx.getImplicitlyUnwrappedOptionalDecl()) {
+      if (!CD->isInvalid() &&
+          CD->getDeclContext()->getDeclaredInterfaceType()->getAnyNominal() !=
+              Ctx.getOptionalDecl()) {
         OptionalTypeKind resultOptionality = OTK_None;
         CD->getResultInterfaceType()->getAnyOptionalObjectType(resultOptionality);
         auto declOptionality = CD->getFailability();

lib/AST/Decl.cpp

@@ -2489,8 +2489,6 @@ OptionalTypeKind NominalTypeDecl::classifyAsOptionalType() const {
   const ASTContext &ctx = getASTContext();
   if (this == ctx.getOptionalDecl()) {
     return OTK_Optional;
-  } else if (this == ctx.getImplicitlyUnwrappedOptionalDecl()) {
-    return OTK_ImplicitlyUnwrappedOptional;
   } else {
     return OTK_None;
   }

lib/AST/Type.cpp

@@ -1235,9 +1235,6 @@ TypeBase *TypeBase::reconstituteSugar(bool Recursive) {
                                    boundGeneric->getGenericArgs()[1]);
       if (boundGeneric->getDecl() == ctx.getOptionalDecl())
         return OptionalType::get(boundGeneric->getGenericArgs()[0]);
-      if (boundGeneric->getDecl() == ctx.getImplicitlyUnwrappedOptionalDecl())
-        return ImplicitlyUnwrappedOptionalType::
-        get(boundGeneric->getGenericArgs()[0]);
     }
     return Ty;
   };
@@ -1294,7 +1291,7 @@ Type SugarType::getSinglyDesugaredTypeSlow() {
     implDecl = Context->getOptionalDecl();
     break;
   case TypeKind::ImplicitlyUnwrappedOptional:
-    implDecl = Context->getImplicitlyUnwrappedOptionalDecl();
+    llvm_unreachable("Should no longer have IUOs");
     break;
   case TypeKind::Dictionary:
     implDecl = Context->getDictionaryDecl();

lib/IRGen/GenMeta.cpp

@@ -2773,13 +2773,7 @@ namespace {
     // aren't mapped correctly because the EnumImplStrategy ends up
     // using the lowered cases, i.e. the cases for Optional<>.
     if (type->classifyAsOptionalType() == OTK_ImplicitlyUnwrappedOptional) {
-      assert(enumElements.size() == 1);
-      auto decl = IGM.Context.getImplicitlyUnwrappedOptionalSomeDecl();
-      auto caseType = decl->getParentEnum()->mapTypeIntoContext(
-        decl->getArgumentInterfaceType())
-          ->getCanonicalType();
-      types.push_back(FieldTypeInfo(caseType, false, false));
-      return getFieldTypeAccessorFn(IGM, type, types);
+      llvm_unreachable("Should not have IUOs.");
     }
 
     for (auto &elt : enumElements) {

lib/SILGen/SILGen.cpp

@@ -61,16 +61,9 @@ SILGenModule::~SILGenModule() {
 
 EnumElementDecl *SILGenModule::getLoweredEnumElementDecl(EnumElementDecl *elt) {
   auto &ctx = getASTContext();
-  if (elt->getParentEnum()->classifyAsOptionalType()
-        != OTK_ImplicitlyUnwrappedOptional)
-    return elt;
-
-  if (elt == ctx.getImplicitlyUnwrappedOptionalSomeDecl()) {
-    return ctx.getOptionalSomeDecl();
-  } else {
-    assert(elt == ctx.getImplicitlyUnwrappedOptionalNoneDecl());
-    return ctx.getOptionalNoneDecl();
-  }
+  assert(elt->getParentEnum()->classifyAsOptionalType() !=
+         OTK_ImplicitlyUnwrappedOptional);
+  return elt;
 }
 
 static SILDeclRef

lib/SILGen/SILGenPattern.cpp

@@ -1762,12 +1762,6 @@ void PatternMatchEmission::emitEnumElementDispatchWithOwnership(
     bool exhaustive = false;
     auto enumDecl = sourceType.getEnumOrBoundGenericEnum();
 
-    // The SIL values will range over Optional, so count against
-    // Optional's cases.
-    if (enumDecl == SGF.getASTContext().getImplicitlyUnwrappedOptionalDecl()) {
-      enumDecl = SGF.getASTContext().getOptionalDecl();
-    }
-
     if (!enumDecl->isResilient(SGF.SGM.M.getSwiftModule(),
                                SGF.F.getResilienceExpansion())) {
       exhaustive = true;
@@ -1990,12 +1984,6 @@ void PatternMatchEmission::emitEnumElementDispatch(
     bool exhaustive = false;
     auto enumDecl = sourceType.getEnumOrBoundGenericEnum();
 
-    // The SIL values will range over Optional, so count against
-    // Optional's cases.
-    if (enumDecl == SGF.getASTContext().getImplicitlyUnwrappedOptionalDecl()) {
-      enumDecl = SGF.getASTContext().getOptionalDecl();
-    }
-
     if (!enumDecl->isResilient(SGF.SGM.M.getSwiftModule(),
                                SGF.F.getResilienceExpansion())) {
       exhaustive = true;

lib/Sema/CSSimplify.cpp

@@ -3560,8 +3560,6 @@ ConstraintSystem::simplifyBridgingConstraint(Type type1,
 
   // Explicit bridging from a value type to an Objective-C class type.
   if (unwrappedFromType->isPotentiallyBridgedValueType() &&
-      unwrappedFromType->getAnyNominal()
-        != TC.Context.getImplicitlyUnwrappedOptionalDecl() &&
       !flags.contains(TMF_ApplyingOperatorParameter) &&
       (unwrappedToType->isBridgeableObjectType() ||
        (unwrappedToType->isExistentialType() &&
@@ -3577,9 +3575,7 @@ ConstraintSystem::simplifyBridgingConstraint(Type type1,
   // Note that specifically require a class or class-constrained archetype
   // here, because archetypes cannot be bridged.
   if (unwrappedFromType->mayHaveSuperclass() &&
-      unwrappedToType->isPotentiallyBridgedValueType() &&
-      unwrappedToType->getAnyNominal()
-        != TC.Context.getImplicitlyUnwrappedOptionalDecl()) {
+      unwrappedToType->isPotentiallyBridgedValueType()) {
     Type bridgedValueType;
     if (auto objcClass = TC.Context.getBridgedToObjC(DC, unwrappedToType,
                                                      &bridgedValueType)) {

lib/Sema/ConstraintSystem.cpp

@@ -1786,42 +1786,7 @@ void ConstraintSystem::resolveOverload(ConstraintLocator *locator,
   }
 }
 
-/// Given that we're accessing a member of an ImplicitlyUnwrappedOptional<T>, is
-/// the DC one of the special cases where we should not instead look at T?
-static bool isPrivilegedAccessToImplicitlyUnwrappedOptional(DeclContext *DC,
-                                                  NominalTypeDecl *D) {
-  assert(D == DC->getASTContext().getImplicitlyUnwrappedOptionalDecl());
-
-  // Walk up through the chain of current contexts.
-  for (; ; DC = DC->getParent()) {
-    assert(DC && "ran out of contexts before finding a module scope?");
-
-    // Look through local contexts.
-    if (DC->isLocalContext()) {
-      continue;
-
-    // If we're in a type context that's defining or extending
-    // ImplicitlyUnwrappedOptional<T>, we're privileged.
-    } else if (DC->isTypeContext()) {
-      if (DC->getAsNominalTypeOrNominalTypeExtensionContext() == D)
-        return true;
-
-    // Otherwise, we're privileged if we're within the same file that
-    // defines ImplicitlyUnwrappedOptional<T>.
-    } else {
-      assert(DC->isModuleScopeContext());
-      return (DC == D->getModuleScopeContext());
-    }
-  }
-}
-
 Type ConstraintSystem::lookThroughImplicitlyUnwrappedOptionalType(Type type) {
-  if (auto boundTy = type->getAs<BoundGenericEnumType>()) {
-    auto boundDecl = boundTy->getDecl();
-    if (boundDecl == TC.Context.getImplicitlyUnwrappedOptionalDecl() &&
-        !isPrivilegedAccessToImplicitlyUnwrappedOptional(DC, boundDecl))
-      return boundTy->getGenericArgs()[0];
-  }
   return Type();
 }