emit a warning + fixit to move @autoclosure/@NoEscape to the type position

instead of from the parameter position.

This should be upgraded to an error later in Swift 3, but we'll give the
community some time to react.

Author: lattner

include/swift/AST/DiagnosticsSema.def

@@ -766,6 +766,10 @@ ERROR(missing_initializer_def,PointsToFirstBadToken,
       "initializer requires a body", ())
 
 // Attributes
+WARNING(attr_decl_attr_now_on_type,none,
+      "%0 is now an attribute on a parameter type, "
+      "instead of on the parameter itself", (StringRef))
+
 ERROR(operator_not_func,none,
       "operators must be declared with 'func'", ())
 ERROR(redefining_builtin_operator,none,

lib/Sema/TypeCheckAttr.cpp

@@ -1559,6 +1559,13 @@ void TypeChecker::checkAutoClosureAttr(ParamDecl *PD, AutoClosureAttr *attr) {
   if (FTy->isAutoClosure())
     return;
 
+  // This decl attribute has been moved to being a type attribute.
+  auto text = attr->isEscaping() ? "@autoclosure(escaping)" : "@autoclosure";
+  diagnose(attr->getLocation(), diag::attr_decl_attr_now_on_type,
+           "@autoclosure")
+    .fixItRemove(attr->getRangeWithAt())
+    .fixItInsert(PD->getTypeLoc().getSourceRange().Start, text);
+
   auto *FuncTyInput = FTy->getInput()->getAs<TupleType>();
   if (!FuncTyInput || FuncTyInput->getNumElements() != 0) {
     diagnose(attr->getLocation(), diag::autoclosure_function_input_nonunit);
@@ -1601,6 +1608,11 @@ void TypeChecker::checkNoEscapeAttr(ParamDecl *PD, NoEscapeAttr *attr) {
   if (FTy->isNoEscape())
     return;
 
+  // This decl attribute has been moved to being a type attribute.
+  diagnose(attr->getLocation(), diag::attr_decl_attr_now_on_type, "@noescape")
+    .fixItRemove(attr->getRangeWithAt())
+    .fixItInsert(PD->getTypeLoc().getSourceRange().Start, "@noescape");
+
   // Change the type to include the noescape bit.
   PD->overwriteType(FunctionType::get(FTy->getInput(), FTy->getResult(),
                                       FTy->getExtInfo().withNoEscape(true)));

test/attr/attr_autoclosure.swift

@@ -68,6 +68,7 @@ struct AutoclosureEscapeTest {
 }
 
 // @autoclosure(escaping)
+// expected-warning @+1 {{@autoclosure is now an attribute on a parameter type, instead of on the parameter itself}} {{13-34=}} {{38-38=@autoclosure(escaping)}}
 func func10(@autoclosure(escaping _: () -> ()) { } // expected-error{{expected ')' in @autoclosure}}
 // expected-note@-1{{to match this opening '('}}
 
@@ -120,3 +121,11 @@ let _ : (@autoclosure(escaping) () -> ()) -> ()
 // escaping is the name of param type
 let _ : (@autoclosure(escaping) -> ()) -> ()  // expected-error {{use of undeclared type 'escaping'}}
 
+
+// Migration
+// expected-warning @+1 {{@autoclosure is now an attribute on a parameter type, instead of on the parameter itself}} {{16-28=}} {{32-32=@autoclosure}}
+func migrateAC(@autoclosure _: () -> ()) { }
+
+// expected-warning @+1 {{@autoclosure is now an attribute on a parameter type, instead of on the parameter itself}} {{17-39=}} {{43-43=@autoclosure(escaping)}}
+func migrateACE(@autoclosure(escaping) _: () -> ()) { }
+

test/attr/attr_noescape.swift

@@ -223,9 +223,9 @@ class NoEscapeImmediatelyApplied {
 
 
 // Reduced example from XCTest overlay, involves a TupleShuffleExpr
-public func XCTAssertTrue(@autoclosure _ expression: () -> Boolean, _ message: String = "", file: StaticString = #file, line: UInt = #line) -> Void {
+public func XCTAssertTrue(_ expression: @autoclosure () -> Boolean, _ message: String = "", file: StaticString = #file, line: UInt = #line) -> Void {
 }
-public func XCTAssert( @autoclosure _ expression: () -> Boolean, _ message: String = "", file: StaticString = #file, line: UInt = #line)  -> Void {
+public func XCTAssert(_ expression: @autoclosure () -> Boolean, _ message: String = "", file: StaticString = #file, line: UInt = #line)  -> Void {
   XCTAssertTrue(expression, message, file: file, line: line);
 }
 
@@ -293,10 +293,10 @@ enum r19997577Type {
 }
 
 // type attribute and decl attribute
-func noescapeD(@noescape f: () -> Bool) {} // ok
+func noescapeD(@noescape f: () -> Bool) {} // expected-warning {{@noescape is now an attribute on a parameter type, instead of on the parameter itself}} {{16-25=}} {{29-29=@noescape}}
 func noescapeT(f: @noescape () -> Bool) {} // ok
-func autoclosureD(@autoclosure f: () -> Bool) {} // ok
+func autoclosureD(@autoclosure f: () -> Bool) {} // expected-warning {{@autoclosure is now an attribute on a parameter type, instead of on the parameter itself}} {{19-31=}} {{35-35=@autoclosure}}
 func autoclosureT(f: @autoclosure () -> Bool) {}  // ok
 
-func noescapeD_noescapeT(@noescape f: @noescape () -> Bool) {} // ok
-func autoclosureD_noescapeT(@autoclosure f: @noescape () -> Bool) {} // ok
+func noescapeD_noescapeT(@noescape f: @noescape () -> Bool) {}
+func autoclosureD_noescapeT(@autoclosure f: @noescape () -> Bool) {} // expected-warning {{@autoclosure is now an attribute on a parameter type, instead of on the parameter itself}} {{29-41=}} {{45-45=@autoclosure}}