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!'.

Most of the changes supporting this were previously merged to master,
but some things were difficult to merge to master without actually
removing IUOs from the type system:
- Dynamic member lookup and dynamic subscripting
- Changes to ensure the bridging peephole still works

Past commits have attempted to retain as much fidelity with how we
were printing things as possible. There are some cases where we still
are not printing things the same way:
- In diagnostics we will print '?' rather than '!'
- Some SourceKit and Code Completion output where we print a Type
  rather than Decl.

Things like module printing via swift-ide-test attempt to print '!'
any place that we now have Optional types that were declared as IUOs.

There are some diagnostics regressions related to the fact that we can
no longer "look through" IUOs. For the same reason some output and
functionality changes in Code Completion. I have an idea of how we can
restore these, and have opened a bug to investigate doing so.

There are some small source compatibility breaks that result from
this change:
- Results of dynamic lookup that are themselves declared IUO can in
  rare circumstances be inferred differently. This shows up in
  test/ClangImporter/objc_parse.swift, where we have
    var optStr = obj.nsstringProperty
  Rather than inferring optStr to be 'String!?', we now infer this to
  be 'String??', which is in line with the expectations of SE-0054.
  The fact that we were only inferring the outermost IUO to be an
  Optional in Swift 4 was a result of the incomplete implementation of
  SE-0054 as opposed to a particular design. This should rarely cause
  problems since in the common-case of actually using the property rather
  than just assigning it to a value with inferred type, we will behave
  the same way.
- Overloading functions with inout parameters strictly by a difference
  in optionality (i.e. Optional<T> vs. ImplicitlyUnwrappedOptional<T>)
  will result in an error rather than the diagnostic that was added
  in Swift 4.1.
- Any place where '!' was being used where it wasn't supposed to be
  allowed by SE-0054 will now treat the '!' as if it were '?'.
  Swift 4.1 generates warnings for these saying that putting '!'
  in that location is deprecated. These locations include for example
  typealiases or any place where '!' is nested in another type like
  `Int!?` or `[Int!]`.

This commit 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.

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

@@ -4114,7 +4114,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
@@ -4073,7 +4073,7 @@ namespace {
           nullability = translateNullability(*typeNullability);
         }
         if (nullability != OTK_None && !errorConvention.hasValue()) {
-          resultTy = OptionalType::get(nullability, resultTy);
+          resultTy = OptionalType::get(resultTy);
           isIUO = nullability == OTK_ImplicitlyUnwrappedOptional;
         }
 
@@ -6115,8 +6115,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();
 
@@ -3188,6 +3185,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

@@ -5066,8 +5066,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());