Reapply:

propagate the no-escape bit from a parameter into a closure-expr argument.  When a 
ClosureExpr is thus inferred to be non-escape, disable the "self." requirement.

.. with fixes.  Thanks again to Dmitri for reverting + adding testcase.



Swift SVN r24115

Author: lattner

lib/AST/Expr.cpp

@@ -84,8 +84,8 @@ SourceLoc Expr::getLoc() const {
 }
 
 Expr *Expr::getSemanticsProvidingExpr() {
-  if (IdentityExpr *PE = dyn_cast<IdentityExpr>(this))
-    return PE->getSubExpr()->getSemanticsProvidingExpr();
+  if (IdentityExpr *IE = dyn_cast<IdentityExpr>(this))
+    return IE->getSubExpr()->getSemanticsProvidingExpr();
 
   if (DefaultValueExpr *DE = dyn_cast<DefaultValueExpr>(this))
     return DE->getSubExpr()->getSemanticsProvidingExpr();

lib/Sema/CSApply.cpp

@@ -4013,6 +4013,27 @@ Expr *ExprRewriter::coerceCallArguments(Expr *arg, Type paramType,
   return shuffle;
 }
 
+/// If the expression is an explicit closure expression (potentially wrapped in
+/// IdentityExprs), change the type of the closure and identities to the
+/// specified type and return true.  Otherwise, return false with no effect.
+static bool applyTypeToClosureExpr(Expr *expr, Type toType) {
+  // Look through identity expressions, like parens.
+  if (auto IE = dyn_cast<IdentityExpr>(expr)) {
+    if (!applyTypeToClosureExpr(IE->getSubExpr(), toType)) return false;
+    IE->setType(toType);
+    return true;
+  }
+
+  // If we found an explicit ClosureExpr, update its type.
+  if (auto CE = dyn_cast<ClosureExpr>(expr)) {
+    CE->setType(toType);
+    return true;
+  }
+  // Otherwise fail.
+  return false;
+}
+
+
 Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
                                  ConstraintLocatorBuilder locator) {
   auto &tc = cs.getTypeChecker();
@@ -4370,8 +4391,24 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
     }
 
     // Coercion from one function type to another.
-    auto fromFunc = fromType->getAs<FunctionType>();
-    if (fromFunc) {
+    if (auto fromFunc = fromType->getAs<FunctionType>()) {
+      // If the input and output types match, then the difference is a change
+      // in the ExtInfo bits.
+      if (fromFunc->getInput()->isEqual(toFunc->getInput()) &&
+          fromFunc->getResult()->isEqual(toFunc->getResult())) {
+        // If the only difference is in the noreturn or noescape bits, try to
+        // propagate them into the expression.
+        auto fromEI = fromFunc->getExtInfo(), toEI = toFunc->getExtInfo();
+        if (fromEI.withIsNoReturn(false).withNoEscape(false) ==
+            toEI.withIsNoReturn(false).withNoEscape(false) &&
+            // Adding - not stripping off - the bits.
+            (!fromEI.isNoReturn() || toEI.isNoReturn()) &&
+            (!fromEI.isNoEscape() || toEI.isNoEscape())) {
+          if (applyTypeToClosureExpr(expr, toType))
+            return expr;
+        }
+      }
+
       return new (tc.Context) FunctionConversionExpr(expr, toType);
     }
   }

lib/Sema/MiscDiagnostics.cpp

@@ -313,6 +313,20 @@ static void diagnoseImplicitSelfUseInClosure(TypeChecker &TC, const Expr *E) {
              DRE->getDecl()->getName().str() == "self";
     }
 
+    /// Return true if this is a closure expression that will require "self."
+    /// qualification of member references.
+    static bool isClosureRequiringSelfQualification(const Expr *E) {
+      if (!isa<ClosureExpr>(E)) return false;
+
+      // If the closure's type was inferred to be noescape, then it doesn't
+      // need qualification.
+      if (E->getType())
+        if (auto *FT = E->getType()->getAs<FunctionType>())
+          return !FT->isNoEscape();
+      return true;
+    }
+
+
     // Don't walk into nested decls.
     bool walkToDeclPre(Decl *D) override {
       return false;
@@ -322,7 +336,7 @@ static void diagnoseImplicitSelfUseInClosure(TypeChecker &TC, const Expr *E) {
 
       // If this is an explicit closure expression - not an autoclosure - then
       // we keep track of the fact that recursive walks are within the closure.
-      if (isa<ClosureExpr>(E))
+      if (isClosureRequiringSelfQualification(E))
         ++InClosure;
 
       // If we aren't in a closure, no diagnostics will be produced.
@@ -362,7 +376,7 @@ static void diagnoseImplicitSelfUseInClosure(TypeChecker &TC, const Expr *E) {
     }
 
     Expr *walkToExprPost(Expr *E) {
-      if (isa<ClosureExpr>(E)) {
+      if (isClosureRequiringSelfQualification(E)) {
         assert(InClosure);
         --InClosure;
       }

test/attr/attr_noescape.swift

@@ -2,16 +2,17 @@
 
 @__noescape var fn : () -> Int = { 4 }  // expected-error {{'__noescape' may only be used on 'parameter' declarations}}
 
-func f(@__noescape fn : () -> Int) {
-  f { 4 }  // ok
+func takesClosure(@__noescape fn : () -> Int) {
+  takesClosure { 4 }  // ok
 }
 
 class SomeClass {
   final var x = 42
 
-  // TODO: We should be able to eliminate this.
   func test() {
-    f { x }       // expected-error {{reference to property 'x' in closure requires explicit 'self.' to make capture semantics explicit}}
+    // Since 'takesClosure' doesn't escape its closure, it doesn't require
+    // "self." qualification of member references.
+    takesClosure { x }
   }