Make escaping_optional_type_argument to be an error, use it instead of original message when object type is a function type

Author: ismetanin

include/swift/AST/DiagnosticsSema.def

@@ -2856,8 +2856,8 @@ ERROR(autoclosure_function_input_nonunit,none,
 ERROR(escaping_non_function_parameter,none,
       "@escaping attribute may only be used in function parameter position", ())
 
-NOTE(escaping_optional_type_argument, none,
-     "closure is already escaping in optional type argument", ())
+ERROR(escaping_optional_type_argument, none,
+      "closure is already escaping in optional type argument", ())
 
 // @_nonEphemeral attribute
 ERROR(non_ephemeral_non_pointer_type,none,
@@ -4047,8 +4047,6 @@ NOTE(overridden_required_initializer_here,none,
 // Functions
 ERROR(attribute_requires_function_type,none,
       "@%0 attribute only applies to function types", (StringRef))
-ERROR(optional_closures_are_already_escaping,none,
-      "Optional closures are already @escaping", ())
 ERROR(unsupported_convention,none,
       "convention '%0' not supported", (StringRef))
 ERROR(unreferenced_generic_parameter,none,

lib/Sema/TypeCheckType.cpp

@@ -2416,19 +2416,19 @@ Type TypeResolver::resolveAttributedType(TypeAttributes &attrs,
 
       if (i == TAK_escaping && ty->getOptionalObjectType()) {
         auto diag = diagnoseInvalid(repr, attrs.getLoc(i),
-                                    diag::optional_closures_are_already_escaping);
-        diag.fixItRemove(getTypeAttrRangeWithAt(Context,
-                                              attrs.getLoc(TAK_escaping)));
+                                    diag::escaping_optional_type_argument);
+        diag.fixItRemove(
+            getTypeAttrRangeWithAt(Context, attrs.getLoc(TAK_escaping)));
       } else {
         auto diag = diagnoseInvalid(repr, attrs.getLoc(i),
                                     diag::attribute_requires_function_type,
                                     TypeAttributes::getAttrName(i));
 
-        // If we see @escaping among the attributes on this type, because it isn't
-        // a function type, we'll remove it.
+        // If we see @escaping among the attributes on this type, because it
+        // isn't a function type, we'll remove it.
         if (i == TAK_escaping) {
-          diag.fixItRemove(getTypeAttrRangeWithAt(Context,
-                                                  attrs.getLoc(TAK_escaping)));
+          diag.fixItRemove(
+              getTypeAttrRangeWithAt(Context, attrs.getLoc(TAK_escaping)));
         }
       }
       attrs.clearAttribute(i);

test/attr/attr_escaping.swift

@@ -72,14 +72,14 @@ struct GenericStruct<T> {}
 
 func misuseEscaping(_ a: @escaping Int) {} // expected-error{{@escaping attribute only applies to function types}} {{26-36=}}
 func misuseEscaping(_ a: (@escaping Int)?) {} // expected-error{{@escaping attribute only applies to function types}} {{27-36=}}
-func misuseEscaping(opt a: @escaping ((Int) -> Int)?) {} // expected-error{{Optional closures are already @escaping}} {{28-38=}}
+func misuseEscaping(opt a: @escaping ((Int) -> Int)?) {} // expected-error{{closure is already escaping in optional type argument}} {{28-38=}}
 
 func misuseEscaping(_ a: (@escaping (Int) -> Int)?) {} // expected-error{{@escaping attribute may only be used in function parameter position}} {{27-36=}}
-  // expected-note@-1{{closure is already escaping in optional type argument}}
+  // expected-error@-1{{closure is already escaping in optional type argument}}
 func misuseEscaping(nest a: (((@escaping (Int) -> Int))?)) {} // expected-error{{@escaping attribute may only be used in function parameter position}} {{32-41=}}
-  // expected-note@-1{{closure is already escaping in optional type argument}}
+  // expected-error@-1{{closure is already escaping in optional type argument}}
 func misuseEscaping(iuo a: (@escaping (Int) -> Int)!) {} // expected-error{{@escaping attribute may only be used in function parameter position}} {{29-38=}}
-  // expected-note@-1{{closure is already escaping in optional type argument}}
+  // expected-error@-1{{closure is already escaping in optional type argument}}
 
 func misuseEscaping(_ a: Optional<@escaping (Int) -> Int>, _ b: Int) {} // expected-error{{@escaping attribute may only be used in function parameter position}} {{35-44=}}
 func misuseEscaping(_ a: (@escaping (Int) -> Int, Int)) {} // expected-error{{@escaping attribute may only be used in function parameter position}} {{27-36=}}