IUO: Generate Optional<T> rather than ImplicitlyUnwrappedOptional<T>.

Stop creating ImplicitlyUnwrappedOptional<T> so that we can remove it
from the type system.

Enable the code that generates disjunctions for Optional<T> and
rewrites expressions based on the original declared type being 'T!'.

This effectively means ImplicitlyUnwrappedOptional<T> is no longer
part of the type system, although I haven't actually removed all of
the code dealing with it yet.

Most of the changes supporting this were previously merged to master,
but some things, like support for dynamic lookup were difficult to put
on master without actually removing IUOs.

ImplicitlyUnwrappedOptional<T> is is dead, long live implicitly
unwrapped Optional<T>!

Resolves rdar://problem/33272674.

Author: rudkx

include/swift/AST/Expr.h

@@ -303,6 +303,10 @@ class alignas(8) Expr {
     NumVariadicArgs : 16
   );
 
+  SWIFT_INLINE_BITFIELD(ForceValueExpr, Expr, 1,
+    ForcedIUO : 1
+  );
+
   SWIFT_INLINE_BITFIELD(InOutToPointerExpr, ImplicitConversionExpr, 1,
     IsNonAccessing : 1
   );
@@ -2507,9 +2511,11 @@ class ForceValueExpr : public Expr {
   SourceLoc ExclaimLoc;
 
 public:
-  ForceValueExpr(Expr *subExpr, SourceLoc exclaimLoc)
+  ForceValueExpr(Expr *subExpr, SourceLoc exclaimLoc, bool forcedIUO = false)
     : Expr(ExprKind::ForceValue, /*Implicit=*/exclaimLoc.isInvalid(), Type()),
-      SubExpr(subExpr), ExclaimLoc(exclaimLoc) {}
+      SubExpr(subExpr), ExclaimLoc(exclaimLoc) {
+    Bits.ForceValueExpr.ForcedIUO = forcedIUO;
+  }
 
   SourceRange getSourceRange() const {
     if (ExclaimLoc.isInvalid())
@@ -2534,6 +2540,10 @@ class ForceValueExpr : public Expr {
   Expr *getSubExpr() const { return SubExpr; }
   void setSubExpr(Expr *expr) { SubExpr = expr; }
 
+  bool isForceOfImplicitlyUnwrappedOptional() const {
+    return Bits.ForceValueExpr.ForcedIUO;
+  }
+
   static bool classof(const Expr *E) {
     return E->getKind() == ExprKind::ForceValue;
   }

include/swift/AST/Types.h

@@ -4094,7 +4094,9 @@ class ImplicitlyUnwrappedOptionalType : public UnarySyntaxSugarType {
   ImplicitlyUnwrappedOptionalType(const ASTContext &ctx, Type base,
                         RecursiveTypeProperties properties)
     : UnarySyntaxSugarType(TypeKind::ImplicitlyUnwrappedOptional, ctx, base,
-                           properties) {}
+                           properties) {
+    //llvm_unreachable("ImplicitlyUnwrappedOptionalType::ImplicitlyUnwrappedOptionalType");
+  }
 
 public:
   /// Return a uniqued optional type with the specified base type.

lib/ClangImporter/ImportDecl.cpp

@@ -1792,7 +1792,7 @@ static ImportedType rectifySubscriptTypes(Type getterType, bool getterIsIUO,
 
   // Create an optional of the object type that can be implicitly
   // unwrapped which subsumes both behaviors.
-  return {ImplicitlyUnwrappedOptionalType::get(setterType), true};
+  return {OptionalType::get(setterType), true};
 }
 
 /// Add an AvailableAttr to the declaration for the given
@@ -4059,7 +4059,7 @@ namespace {
           nullability = translateNullability(*typeNullability);
         }
         if (nullability != OTK_None && !errorConvention.hasValue()) {
-          resultTy = OptionalType::get(nullability, resultTy);
+          resultTy = OptionalType::get(resultTy);
           isIUO = nullability == OTK_ImplicitlyUnwrappedOptional;
         }
 
@@ -6101,8 +6101,8 @@ ConstructorDecl *SwiftDeclConverter::importConstructor(
 
   // Rebuild the function type with the appropriate result type;
   Type resultTy = selfTy;
-  if (failability)
-    resultTy = OptionalType::get(failability, resultTy);
+  if (failability != OTK_None)
+    resultTy = OptionalType::get(resultTy);
 
   type = FunctionType::get(oldFnType->getInput(), resultTy,
                            oldFnType->getExtInfo());

lib/ClangImporter/ImportType.cpp

@@ -160,17 +160,6 @@ namespace {
     return OptKind;
   }
 
-  /// Wrap a type in the Optional type appropriate to the import kind.
-  static Type getOptionalType(Type payloadType, ImportTypeKind kind,
-                              OptionalTypeKind OptKind) {
-    OptKind = getOptionalKind(kind, OptKind);
-
-    if (OptKind == OTK_None)
-      return payloadType;
-
-    return OptionalType::get(OptKind, payloadType);
-  }
-
   class SwiftTypeConverter :
     public clang::TypeVisitor<SwiftTypeConverter, ImportResult>
   {
@@ -1277,7 +1266,7 @@ static ImportedType adjustTypeForConcreteImport(
     auto resultTy = boundGenericTy->getGenericArgs().front();
     if (OTK != OTK_None) {
       assert(OTK != OTK_ImplicitlyUnwrappedOptional);
-      resultTy = OptionalType::get(OTK, resultTy);
+      resultTy = OptionalType::get(resultTy);
     }
 
     StringRef pointerName;
@@ -1398,14 +1387,6 @@ static ImportedType adjustTypeForConcreteImport(
   return {importedType, isIUO};
 }
 
-static Type adjustOptionality(ImportedType importedType) {
-  if (!importedType.isImplicitlyUnwrapped())
-    return importedType.getType();
-
-  return ImplicitlyUnwrappedOptionalType::get(
-      importedType.getType()->getOptionalObjectType());
-}
-
 ImportedType ClangImporter::Implementation::importType(
     clang::QualType type, ImportTypeKind importKind, bool allowNSUIntegerAsInt,
     Bridgeability bridging, OptionalTypeKind optionality,
@@ -1460,10 +1441,7 @@ ImportedType ClangImporter::Implementation::importType(
   assert(!adjustedType ||
          !adjustedType.getType()->getImplicitlyUnwrappedOptionalObjectType());
 
-  // Make an IUO type based on isIUO. This will be removed when IUOs
-  // are removed from the type system.
-  return {adjustOptionality(adjustedType),
-          adjustedType.isImplicitlyUnwrapped()};
+  return adjustedType;
 }
 
 Type ClangImporter::Implementation::importTypeIgnoreIUO(
@@ -1474,12 +1452,8 @@ Type ClangImporter::Implementation::importTypeIgnoreIUO(
   auto importedType = importType(type, importKind, allowNSUIntegerAsInt,
                                  bridging, optionality, resugarNSErrorPointer);
 
-  // We allow IUO types to be returned at the moment. At some point we
-  // will never generate them and this can be removed.
-  assert(!importedType || importedType.isImplicitlyUnwrapped() ==
-                              !importedType.getType()
-                                   ->getImplicitlyUnwrappedOptionalObjectType()
-                                   .isNull());
+  assert(!importedType ||
+         !importedType.getType()->getImplicitlyUnwrappedOptionalObjectType());
 
   return importedType.getType();
 }
@@ -1558,7 +1532,7 @@ static Type applyNoEscape(Type type) {
   // Recurse into optional types.
   OptionalTypeKind optKind;
   if (Type objectType = type->getAnyOptionalObjectType(optKind)) {
-    return OptionalType::get(optKind, applyNoEscape(objectType));
+    return OptionalType::get(applyNoEscape(objectType));
   }
 
   // Apply @noescape to function types.
@@ -2013,7 +1987,7 @@ ImportedType ClangImporter::Implementation::importMethodType(
     if (nonOptionalTy->isAnyClassReferenceType()) {
       swiftResultTy = getUnmanagedType(*this, nonOptionalTy);
       if (OptionalityOfReturn != OTK_None)
-        swiftResultTy = OptionalType::get(OptionalityOfReturn, swiftResultTy);
+        swiftResultTy = OptionalType::get(swiftResultTy);
     }
   }
 
@@ -2085,11 +2059,14 @@ ImportedType ClangImporter::Implementation::importMethodType(
     bool paramIsIUO;
     if (kind == SpecialMethodKind::NSDictionarySubscriptGetter &&
         paramTy->isObjCIdType()) {
-      swiftParamTy = getOptionalType(getNSCopyingType(),
-                                     ImportTypeKind::Parameter,
-                                     optionalityOfParam);
       auto optKind =
           getOptionalKind(ImportTypeKind::Parameter, optionalityOfParam);
+
+      if (optKind == OTK_None)
+        swiftParamTy = getNSCopyingType();
+      else
+        swiftParamTy = OptionalType::get(getNSCopyingType());
+
       paramIsIUO = optKind == OTK_ImplicitlyUnwrappedOptional;
     } else {
       ImportTypeKind importKind = ImportTypeKind::Parameter;

lib/IDE/CodeCompletion.cpp

@@ -1944,9 +1944,6 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
       suffix = "!";
     }
 
-    // FIXME: This goes away when IUOs are removed from the type system.
-    assert(T->getReferenceStorageReferent()->getImplicitlyUnwrappedOptionalObjectType());
-
     Type ObjectType =
         T->getReferenceStorageReferent()->getAnyOptionalObjectType();
 
@@ -3182,6 +3179,8 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
         }
       }
     } else if (Type Unwrapped = ExprType->getImplicitlyUnwrappedOptionalObjectType()) {
+      // FIXME: This can go away when IUOs have been removed from the type
+      // system.
       lookupVisibleMemberDecls(*this, Unwrapped, CurrDeclContext,
                                TypeResolver.get(),
                                IncludeInstanceMembers);

lib/SILGen/SILGenConvert.cpp

@@ -1153,8 +1153,7 @@ Optional<Conversion> Conversion::adjustForInitialForceValue() const {
 
   case BridgeToObjC: {
     auto sourceOptType =
-      ImplicitlyUnwrappedOptionalType::get(getBridgingSourceType())
-        ->getCanonicalType();
+      OptionalType::get(getBridgingSourceType())->getCanonicalType();
     return Conversion::getBridging(ForceAndBridgeToObjC,
                                    sourceOptType,
                                    getBridgingResultType(),

lib/SILGen/SILGenExpr.cpp

@@ -5068,8 +5068,7 @@ RValue RValueEmitter::emitForceValue(ForceValueExpr *loc, Expr *E,
   // If this is an implicit force of an ImplicitlyUnwrappedOptional,
   // and we're emitting into an unbridging conversion, try adjusting the
   // context.
-  if (loc->isImplicit() &&
-      E->getType()->getImplicitlyUnwrappedOptionalObjectType()) {
+  if (loc->isImplicit() && loc->isForceOfImplicitlyUnwrappedOptional()) {
     if (auto conv = C.getAsConversion()) {
       if (auto adjusted = conv->getConversion().adjustForInitialForceValue()) {
         auto value =

lib/SILGen/SILGenPoly.cpp

@@ -392,9 +392,10 @@ ManagedValue Transform::transform(ManagedValue v,
     });
   }
 
-  // If the value is IUO, but the desired formal type isn't optional, force it.
-  if (inputOTK == OTK_ImplicitlyUnwrappedOptional
-      && outputOTK == OTK_None) {
+  // If the value is an optional, but the desired formal type isn't an
+  // optional or Any, force it.
+  if (inputOTK != OTK_None && outputOTK == OTK_None
+      && !outputSubstType->isExistentialType()) {
     v = SGF.emitCheckedGetOptionalValueFrom(Loc, v,
                                             SGF.getTypeLowering(v.getType()),
                                             SGFContext());