Fix more places where were allowing IUOs but shouldn't.

My previous commit, f9b82bc, failed to
ensure that IUOs could not be nested inside of other types in all
positions.

Author: rudkx

lib/Sema/TypeCheckDecl.cpp

@@ -4252,7 +4252,6 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
                                      &resolver);
     TypeResolutionOptions options;
     options |= TR_SubscriptParameters;
-    options |= TR_AllowIUO;
 
     isInvalid |= TC.typeCheckParameterList(SD->getIndices(), SD,
                                            options,
@@ -4792,8 +4791,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
                              GenericTypeResolver &resolver) {
     bool hadError = false;
     for (auto paramList : fd->getParameterLists()) {
-      hadError |=
-          TC.typeCheckParameterList(paramList, fd, TR_AllowIUO, resolver);
+      hadError |= TC.typeCheckParameterList(paramList, fd,
+                                            TypeResolutionOptions(), resolver);
     }
 
     return hadError;

lib/Sema/TypeCheckGeneric.cpp

@@ -457,7 +457,7 @@ static bool checkGenericFuncSignature(TypeChecker &tc,
   // Check the parameter patterns.
   for (auto params : func->getParameterLists()) {
     // Check the pattern.
-    if (tc.typeCheckParameterList(params, func, TR_AllowIUO,
+    if (tc.typeCheckParameterList(params, func, TypeResolutionOptions(),
                                   resolver))
       badType = true;
 
@@ -932,8 +932,7 @@ static bool checkGenericSubscriptSignature(TypeChecker &tc,
 
   // Check the element type.
   badType |= tc.validateType(subscript->getElementTypeLoc(), subscript,
-                             TypeResolutionOptions(),
-                             &resolver);
+                             TR_AllowIUO, &resolver);
 
   // Infer requirements from it.
   if (genericParams && builder) {
@@ -951,7 +950,6 @@ static bool checkGenericSubscriptSignature(TypeChecker &tc,
 
   TypeResolutionOptions options;
   options |= TR_SubscriptParameters;
-  options |= TR_AllowIUO;
 
   badType |= tc.typeCheckParameterList(params, subscript,
                                        options,

lib/Sema/TypeCheckPattern.cpp

@@ -691,6 +691,9 @@ static bool validateParameterType(ParamDecl *decl, DeclContext *DC,
   auto elementOptions = (options |
                          (decl->isVariadic() ? TR_VariadicFunctionInput
                                              : TR_FunctionInput));
+  if (!decl->isVariadic())
+    elementOptions |= TR_AllowIUO;
+
   bool hadError = false;
 
   // We might have a null typeLoc if this is a closure parameter list,

lib/Sema/TypeCheckType.cpp

@@ -501,6 +501,7 @@ Type TypeChecker::applyUnboundGenericArguments(
   options -= TR_FunctionInput;
   options -= TR_TypeAliasUnderlyingType;
   options -= TR_AllowUnavailableProtocol;
+  options -= TR_AllowIUO;
 
   assert(genericArgs.size() == decl->getGenericParams()->size() &&
          "invalid arguments, use applyGenericArguments for diagnostic emitting");
@@ -2774,17 +2775,18 @@ Type TypeResolver::resolveOptionalType(OptionalTypeRepr *repr,
 Type TypeResolver::resolveImplicitlyUnwrappedOptionalType(
        ImplicitlyUnwrappedOptionalTypeRepr *repr,
        TypeResolutionOptions options) {
-  auto elementOptions = withoutContext(options, true);
-  elementOptions |= TR_ImmediateOptionalTypeArgument;
 
   // Swift version >= 5? Use the newer check for IUOs appearing in
   // illegal positions.
-  if (TC.Context.isSwiftVersionAtLeast(5) &&
-      !elementOptions.contains(TR_AllowIUO)) {
+  if (TC.Context.isSwiftVersionAtLeast(5) && !options.contains(TR_AllowIUO)) {
     TC.diagnose(repr->getStartLoc(), diag::iuo_in_illegal_position)
       .fixItReplace(repr->getExclamationLoc(), "?");
+    return ErrorType::get(Context);
   }
 
+  auto elementOptions = withoutContext(options, true);
+  elementOptions |= TR_ImmediateOptionalTypeArgument;
+
   // The T in T! is a generic type argument and therefore always an AST type.
   // FIXME: diagnose non-materializability of element type!
   Type baseTy = resolveType(repr->getBase(), elementOptions);

lib/Sema/TypeChecker.h

@@ -557,6 +557,7 @@ withoutContext(TypeResolutionOptions options, bool preserveSIL = false) {
   options -= TR_VariadicFunctionInput;
   options -= TR_EnumCase;
   options -= TR_ImmediateOptionalTypeArgument;
+  options -= TR_AllowIUO;
   if (!preserveSIL) options -= TR_SILType;
   return options;
 }

test/Sema/diag_erroneous_iuo.swift

@@ -1,22 +1,72 @@
 // RUN: %target-typecheck-verify-swift -swift-version 5
 
+// These are all legal uses of '!'.
+struct Fine {
+  var value: Int!
+
+  func m(_ unnamed: Int!, named: Int!) -> Int! { return unnamed }
+  static func s(_ unnamed: Int!, named: Int!) -> Int! { return named }
+
+  init(_ value: Int) { self.value = value }
+  init!() { return nil }
+
+  subscript (
+    index: Int!
+  )     -> Int! {
+    return index
+  }
+
+  subscript<T> (
+    index: T!
+  )     -> T! {
+    return index
+  }
+}
+
 let _: ImplicitlyUnwrappedOptional<Int> = 1 // expected-error {{the spelling 'ImplicitlyUnwrappedOptional' is unsupported; use '!' after the type name}}{{8-36=}}{{39-39=!}}{{39-40=}}
 let _: ImplicitlyUnwrappedOptional = 1 // expected-error {{the spelling 'ImplicitlyUnwrappedOptional' in unsupported; use an explicit type followed by '!'}}
 
 extension ImplicitlyUnwrappedOptional {} // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
 
-func function(
+func functionSpelling(
   _: ImplicitlyUnwrappedOptional<Int> // expected-error {{the spelling 'ImplicitlyUnwrappedOptional' is unsupported; use '!' after the type name}}{{6-34=}}{{37-37=!}}{{37-38=}}
 ) -> ImplicitlyUnwrappedOptional<Int> { // expected-error {{the spelling 'ImplicitlyUnwrappedOptional' is unsupported; use '!' after the type name}}{{6-34=}}{{37-37=!}}{{37-38=}}
   return 1
 }
 
+// Okay, like in the method case.
+func functionSigil(
+  _: Int!
+) -> Int! {
+  return 1
+}
+
+// Not okay because '!' is not at the top level of the type.
+func functionSigilArray(
+  _: [Int!] // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
+) -> [Int!] { // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
+  return [1]
+}
+
 func genericFunction<T>(
   iuo: ImplicitlyUnwrappedOptional<T> // expected-error {{the spelling 'ImplicitlyUnwrappedOptional' is unsupported; use '!' after the type name}}{{8-36=}}{{37-37=!}}{{37-38=}}
 ) -> ImplicitlyUnwrappedOptional<T> { // expected-error {{the spelling 'ImplicitlyUnwrappedOptional' is unsupported; use '!' after the type name}}{{6-34=}}{{35-35=!}}{{35-36=}}
   return iuo
 }
 
+// Okay, like in the non-generic case.
+func genericFunctionSigil<T>(
+  iuo: T!
+) -> T! {
+  return iuo
+}
+
+func genericFunctionSigilArray<T>(
+  iuo: [T!] // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
+) -> [T!] { // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
+  return iuo
+}
+
 protocol P {
   associatedtype T
   associatedtype U
@@ -26,11 +76,23 @@ struct S : P {
   typealias T = ImplicitlyUnwrappedOptional<Int> // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
   typealias U = Optional<ImplicitlyUnwrappedOptional<Int>> // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
 
+  typealias V = Int!  // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
+  typealias W = Int!? // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
+
+  var x: V
+  var y: W
+
   subscript (
     index: ImplicitlyUnwrappedOptional<Int> // expected-error {{the spelling 'ImplicitlyUnwrappedOptional' is unsupported; use '!' after the type name}}{{12-40=}}{{43-43=!}}{{43-44=}}
   )     -> ImplicitlyUnwrappedOptional<Int> { // expected-error {{the spelling 'ImplicitlyUnwrappedOptional' is unsupported; use '!' after the type name}}{{12-40=}}{{43-43=!}}{{43-44=}}
     return index
   }
+
+  subscript<T> (
+    index: ImplicitlyUnwrappedOptional<T> // expected-error {{the spelling 'ImplicitlyUnwrappedOptional' is unsupported; use '!' after the type name}}{{12-40=}}{{41-41=!}}{{41-42=}}
+  )     -> ImplicitlyUnwrappedOptional<T> { // expected-error {{the spelling 'ImplicitlyUnwrappedOptional' is unsupported; use '!' after the type name}}{{12-40=}}{{41-41=!}}{{41-42=}}
+    return index
+  }
 }
 
 func generic<T : P>(_: T) where T.T == ImplicitlyUnwrappedOptional<Int> { } // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
@@ -45,16 +107,33 @@ func testClosure() -> Int {
 }
 
 _ = Array<Int!>() // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
+let _: Array<Int!> = [1] // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
 _ = [Int!]() // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
+let _: [Int!] = [1] // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
 _ = Optional<Int!>(nil) // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
+let _: Optional<Int!> = nil // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
 _ = Int!?(0) // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
+let _: Int!? = 0 // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
 _ = (
   Int!, // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
-  Float!, // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
-  String! // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
+  Float!,
+  String!
 )(1, 2.0, "3")
+let _: (
+  Int!, // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
+  Float!,
+  String!
+) = (1, 2.0, "3")
 
-struct Generic<T, U, C> {}
+struct Generic<T, U, C> {
+  init(_ t: T, _ u: U, _ c: C) {}
+}
 _ = Generic<Int!, // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
-            Float!, // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
-            String!>() // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
+            Float!,
+            String!>(1, 2.0, "3")
+let _: Generic<Int!, // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
+               Float!,
+               String!> = Generic(1, 2.0, "3")
+
+func vararg(_ first: Int, more: Int!...) { // expected-error {{implicitly unwrapped optionals are only allowed at top level and as function results}}
+}