[3.0 compat] Don't diagnose @escaping var-arg closures.

include/swift/AST/ASTContext.h

@@ -784,6 +784,9 @@ class ASTContext {
                             clang::ObjCInterfaceDecl *classDecl,
                             bool forInstance);
 
+  /// Whether our effective Swift version is in the Swift 3 family
+  bool isSwiftVersion3() const { return LangOpts.isSwiftVersion3(); }
+
 private:
   friend class Decl;
   Optional<RawComment> getRawComment(const Decl *D);

include/swift/Basic/LangOptions.h

@@ -227,6 +227,11 @@ namespace swift {
       return CustomConditionalCompilationFlags;
     }
 
+    /// Whether our effective Swift version is in the Swift 3 family
+    bool isSwiftVersion3() const {
+      return EffectiveLanguageVersion.isVersion3();
+    }
+
     /// Returns true if the 'os' platform condition argument represents
     /// a supported target operating system.
     ///

include/swift/Basic/Version.h

@@ -95,6 +95,9 @@ class Version {
   /// are attempting to maintain backward-compatibility support for.
   bool isValidEffectiveLanguageVersion() const;
 
+  /// Whether this version is in the Swift 3 family
+  bool isVersion3() const { return !empty() && Components[0] == 3; }
+
   /// Parse a version in the form used by the _compiler_version \#if condition.
   static Version parseCompilerVersionString(StringRef VersionString,
                                             SourceLoc Loc,

lib/Basic/Version.cpp

@@ -291,8 +291,13 @@ Version::isValidEffectiveLanguageVersion() const
   // Whitelist of backward-compatibility versions that we permit passing as
   // -swift-version <vers>
   char const *whitelist[] = {
+    // Swift 3 family
     "3",
     "3.0",
+
+    // Swift 4 family
+    "4",
+    "4.0",
   };
   for (auto const i : whitelist) {
     auto v = parseVersionString(i, SourceLoc(), nullptr);

lib/Sema/TypeCheckType.cpp

@@ -2032,8 +2032,14 @@ Type TypeResolver::resolveAttributedType(TypeAttributes &attrs,
   // Handle @escaping
   if (hasFunctionAttr && ty->is<FunctionType>()) {
     if (attrs.has(TAK_escaping)) {
+      // For compatibility with 3.0, we don't emit an error if it appears on a
+      // variadic argument list.
+      bool skipDiagnostic =
+          isVariadicFunctionParam && Context.isSwiftVersion3();
+
       // The attribute is meaningless except on parameter types.
-      if (!isFunctionParam) {
+      bool shouldDiagnose = !isFunctionParam && !skipDiagnostic;
+      if (shouldDiagnose) {
         auto &SM = TC.Context.SourceMgr;
         auto loc = attrs.getLoc(TAK_escaping);
         auto attrRange = SourceRange(

test/Compatibility/attr_escaping.swift

@@ -0,0 +1,10 @@
+// RUN: %target-parse-verify-swift
+
+// This is allowed, in order to keep source compat with Swift version 3.0.
+func takesVarargsOfFunctionsExplicitEscaping(_ fns: @escaping () -> ()...) {} 
+
+func takesVarargsOfFunctions(_ fn: () -> (), _ fns: () -> ()...) {
+		// expected-note@-1{{parameter 'fn' is implicitly non-escaping}}
+	takesVarargsOfFunctionsExplicitEscaping(fns[0], fns[1]) // ok
+	takesVarargsOfFunctionsExplicitEscaping(fn) // expected-error{{passing non-escaping parameter 'fn' to function expecting an @escaping closure}}
+} 

test/attr/attr_escaping.swift

@@ -1,4 +1,4 @@
-// RUN: %target-parse-verify-swift
+// RUN: %target-parse-verify-swift -swift-version 4
 
 @escaping var fn : () -> Int = { 4 }  // expected-error {{attribute can only be applied to types, not declarations}}
 func paramDeclEscaping(@escaping fn: (Int) -> Void) {} // expected-error {{attribute can only be applied to types, not declarations}}
@@ -140,6 +140,8 @@ func takesVarargsOfFunctions(fns: () -> ()...) {
   }
 }
 
+func takesVarargsOfFunctionsExplicitEscaping(fns: @escaping () -> ()...) {} // expected-error{{@escaping attribute may only be used in function parameter position}}
+
 func takesNoEscapeFunction(fn: () -> ()) { // expected-note {{parameter 'fn' is implicitly non-escaping}}
   takesVarargsOfFunctions(fns: fn) // expected-error {{passing non-escaping parameter 'fn' to function expecting an @escaping closure}}
 }