Add new error diagnostic for escaping optional closures

Author: ismetanin

include/swift/AST/DiagnosticsSema.def

@@ -4047,6 +4047,8 @@ 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

@@ -2414,20 +2414,21 @@ Type TypeResolver::resolveAttributedType(TypeAttributes &attrs,
       if (!attrs.has(i))
         continue;
 
-      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 (i == TAK_escaping) {
+      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)));
-        // Specialize the diagnostic for Optionals.
-        if (ty->getOptionalObjectType()) {
-          diag.flush();
-          diagnoseInvalid(repr, repr->getLoc(),
-                          diag::escaping_optional_type_argument);
+                                              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 (i == TAK_escaping) {
+          diag.fixItRemove(getTypeAttrRangeWithAt(Context,
+                                                  attrs.getLoc(TAK_escaping)));
         }
       }
       attrs.clearAttribute(i);

test/attr/attr_escaping.swift

@@ -72,8 +72,7 @@ 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{{@escaping attribute only applies to function types}} {{28-38=}}
-  // expected-note@-1{{closure is already escaping in optional type argument}}
+func misuseEscaping(opt a: @escaping ((Int) -> Int)?) {} // expected-error{{Optional closures are already @escaping}} {{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}}