Initial implementation of SE-0054 "Abolish IUO Type" (#2322)

This is a squash of the following commits:

* [SE-0054] Import function pointer arg, return types, typedefs as optional

IUOs are only allowed on function decl arguments and return types, so
don't import typedefs or function pointer args or return types as IUO.

* [SE-0054] Only allow IUOs in function arg and result type.

When validating a TypeRepr, raise a diagnostic if an IUO is found
anywhere other thn the top level or as a function parameter or return
tpye.

* [SE-0054] Disable inference of IUOs by default

When considering a constraint of the form '$T1 is convertible to T!',
generate potential bindings 'T' and 'T?' for $T1, but not 'T!'. This
prevents variables without explicit type information from ending up with
IUO type. It also prevents implicit instantiation of functions and types
with IUO type arguments.

* [SE-0054] Remove the -disable-infer-iuos flag.

* Add nonnull annotations to ObjectiveCTests.h in benchmark suite.

Author: cwillmor

benchmark/utils/ObjectiveCTests/ObjectiveCTests.h

@@ -12,6 +12,8 @@
 
 #import <Foundation/Foundation.h>
 
+NS_ASSUME_NONNULL_BEGIN
+
 @interface BridgeTester : NSObject {
   NSString *myString;
   NSArray<NSString *> *myArrayOfStrings;
@@ -24,3 +26,5 @@
 - (NSArray<NSString *> *)testToArrayOfStrings;
 
 @end
+
+NS_ASSUME_NONNULL_END

include/swift/AST/DiagnosticsSema.def

@@ -1461,6 +1461,10 @@ NOTE(override_unnecessary_IUO_use_strict,none,
 NOTE(override_unnecessary_IUO_silence,none,
      "add parentheses to silence this warning", ())
 
+ERROR(iuo_in_illegal_position,none,
+      "implicitly unwrapped optionals are only allowed at top level and as "
+      "function results", ())
+
 ERROR(override_mutable_covariant_property,none,
       "cannot override mutable property %0 of type %1 with covariant type %2",
       (Identifier, Type, Type))

include/swift/Basic/LangOptions.h

@@ -157,9 +157,6 @@ namespace swift {
     /// Enable the Swift 3 migration via Fix-Its.
     bool Swift3Migration = false;
 
-    /// Allow IUO types to be inferred for otherwise untyped variables.
-    bool InferIUOs = true;
-
     /// Sets the target we are building for and updates platform conditions
     /// to match.
     ///

include/swift/Option/FrontendOptions.td

@@ -244,10 +244,6 @@ def swift3_migration :
   Flag<["-"], "swift3-migration">,
   HelpText<"Enable Fix-It based migration aids for Swift 3">;
 
-def disable_infer_iuos :
-  Flag<["-"], "disable-infer-iuos">,
-  HelpText<"Disable inferring IUO type for otherwise unconstrained variables">;
-
 def warn_omit_needless_words :
   Flag<["-"], "Womit-needless-words">,
   HelpText<"Warn about needless words in names">;

lib/ClangImporter/ImportDecl.cpp

@@ -1325,13 +1325,15 @@ namespace {
             auto storedUnderlyingType = Impl.importType(
                 Decl->getUnderlyingType(), ImportTypeKind::Value,
                 isInSystemModule(DC),
-                Decl->getUnderlyingType()->isBlockPointerType());
+                Decl->getUnderlyingType()->isBlockPointerType(),
+                OTK_Optional);
 
             // Find a bridged type, which may be different
             auto computedPropertyUnderlyingType = Impl.importType(
                 Decl->getUnderlyingType(), ImportTypeKind::Property,
                 isInSystemModule(DC),
-                Decl->getUnderlyingType()->isBlockPointerType());
+                Decl->getUnderlyingType()->isBlockPointerType(),
+                OTK_Optional);
 
             if (storedUnderlyingType.getCanonicalTypeOrNull() ==
                 computedPropertyUnderlyingType.getCanonicalTypeOrNull()) {
@@ -1365,7 +1367,8 @@ namespace {
         SwiftType = Impl.importType(ClangType,
                                     ImportTypeKind::Typedef,
                                     isInSystemModule(DC),
-                                    ClangType->isBlockPointerType());
+                                    ClangType->isBlockPointerType(),
+                                    OTK_Optional);
       }
 
       if (!SwiftType)

lib/ClangImporter/ImportType.cpp

@@ -456,7 +456,8 @@ namespace {
       auto resultTy = Impl.importType(type->getReturnType(),
                                       ImportTypeKind::Result,
                                       AllowNSUIntegerAsInt,
-                                      CanFullyBridgeTypes);
+                                      CanFullyBridgeTypes,
+                                      OTK_Optional);
       if (!resultTy)
         return Type();
 
@@ -466,7 +467,8 @@ namespace {
            param != paramEnd; ++param) {
         auto swiftParamTy = Impl.importType(*param, ImportTypeKind::Parameter,
                                             AllowNSUIntegerAsInt,
-                                            CanFullyBridgeTypes);
+                                            CanFullyBridgeTypes,
+                                            OTK_Optional);
         if (!swiftParamTy)
           return Type();
 
@@ -489,7 +491,8 @@ namespace {
       auto resultTy = Impl.importType(type->getReturnType(),
                                       ImportTypeKind::Result,
                                       AllowNSUIntegerAsInt,
-                                      CanFullyBridgeTypes);
+                                      CanFullyBridgeTypes,
+                                      OTK_Optional);
       if (!resultTy)
         return Type();
 

lib/Frontend/CompilerInvocation.cpp

@@ -760,9 +760,6 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   Opts.WarnOmitNeedlessWords = Args.hasArg(OPT_warn_omit_needless_words);
   Opts.StripNSPrefix |= Args.hasArg(OPT_enable_strip_ns_prefix);
   Opts.InferImportAsMember |= Args.hasArg(OPT_enable_infer_import_as_member);
-  if (Args.hasArg(OPT_disable_infer_iuos)) {
-    Opts.InferIUOs = false;
-  }
 
   Opts.EnableThrowWithoutTry |= Args.hasArg(OPT_enable_throw_without_try);
 

lib/Sema/CSSolver.cpp

@@ -875,18 +875,15 @@ static PotentialBindings getPotentialBindings(ConstraintSystem &cs,
       }
     }
 
+    // Don't deduce IUO types.
     Type alternateType;
-    ASTContext &ctx = cs.getTypeChecker().Context;
-    if (!ctx.LangOpts.InferIUOs) {
-      // Don't deduce IUO types.
-      if (kind == AllowedBindingKind::Supertypes &&
-          constraint->getKind() >= ConstraintKind::Conversion &&
-          constraint->getKind() <= ConstraintKind::OperatorArgumentConversion) {
-        if (auto objectType =
-            cs.lookThroughImplicitlyUnwrappedOptionalType(type)) {
-          type = OptionalType::get(objectType);
-          alternateType = objectType;
-        }
+    if (kind == AllowedBindingKind::Supertypes &&
+        constraint->getKind() >= ConstraintKind::Conversion &&
+        constraint->getKind() <= ConstraintKind::OperatorArgumentConversion) {
+      if (auto objectType =
+          cs.lookThroughImplicitlyUnwrappedOptionalType(type)) {
+        type = OptionalType::get(objectType);
+        alternateType = objectType;
       }
     }
 

lib/Sema/TypeCheckType.cpp

@@ -1340,6 +1340,64 @@ Type TypeChecker::resolveIdentifierType(
   return result;
 }
 
+// Returns true if any illegal IUOs were found. If inference of IUO type is disabled, IUOs may only be specified in the following positions:
+//  * outermost type
+//  * function param
+//  * function return type
+static bool checkForIllegalIUOs(TypeChecker &TC, TypeRepr *Repr,
+                                TypeResolutionOptions Options) {
+  class IllegalIUOWalker : public ASTWalker {
+    TypeChecker &TC;
+    SmallVector<bool, 4> IUOsAllowed;
+    bool FoundIllegalIUO = false;
+
+  public:
+    IllegalIUOWalker(TypeChecker &TC, bool IsGenericParameter)
+      : TC(TC)
+      , IUOsAllowed{!IsGenericParameter} {}
+
+    bool walkToTypeReprPre(TypeRepr *T) {
+      bool iuoAllowedHere = IUOsAllowed.back();
+
+      // Raise a diagnostic if we run into a prohibited IUO.
+      if (!iuoAllowedHere) {
+        if (auto *iuoTypeRepr =
+            dyn_cast<ImplicitlyUnwrappedOptionalTypeRepr>(T)) {
+          TC.diagnose(iuoTypeRepr->getStartLoc(), diag::iuo_in_illegal_position)
+            .fixItReplace(iuoTypeRepr->getExclamationLoc(), "?");
+          FoundIllegalIUO = true;
+        }
+      }
+
+      bool childIUOsAllowed = false;
+      if (iuoAllowedHere) {
+        if (auto *tupleTypeRepr = dyn_cast<TupleTypeRepr>(T)) {
+          if (tupleTypeRepr->isParenType()) {
+            childIUOsAllowed = true;
+          }
+        } else if (isa<FunctionTypeRepr>(T)) {
+          childIUOsAllowed = true;
+        } else if (isa<AttributedTypeRepr>(T) || isa<InOutTypeRepr>(T)) {
+          childIUOsAllowed = true;
+        }
+      }
+      IUOsAllowed.push_back(childIUOsAllowed);
+      return true;
+    }
+
+    bool walkToTypeReprPost(TypeRepr *T) {
+      IUOsAllowed.pop_back();
+      return true;
+    }
+
+    bool getFoundIllegalIUO() const { return FoundIllegalIUO; }
+  };
+
+  IllegalIUOWalker Walker(TC, Options.contains(TR_GenericSignature));
+  Repr->walk(Walker);
+  return Walker.getFoundIllegalIUO();
+}
+
 bool TypeChecker::validateType(TypeLoc &Loc, DeclContext *DC,
                                TypeResolutionOptions options,
                                GenericTypeResolver *resolver,
@@ -1351,6 +1409,9 @@ bool TypeChecker::validateType(TypeLoc &Loc, DeclContext *DC,
     return Loc.isError();
 
   if (Loc.getType().isNull()) {
+    // Raise error if we parse an IUO type in an illegal position.
+    checkForIllegalIUOs(*this, Loc.getTypeRepr(), options);
+
     auto type = resolveType(Loc.getTypeRepr(), DC, options, resolver,
                             unsatisfiedDependency);
     if (!type) {

stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb

@@ -599,7 +599,7 @@ func _printDebuggingAdvice(_ fullTestName: String) {
   var invocation = [Process.arguments[0]]
   let interpreter = getenv("SWIFT_INTERPRETER")
   if interpreter != nil {
-    if let interpreterCmd = String(validatingUTF8: interpreter) {
+    if let interpreterCmd = String(validatingUTF8: interpreter!) {
         invocation.insert(interpreterCmd, at: 0)
     }
   }