Sema: Rewrite partial applications into closures

When a method is called with fewer than two parameter lists,
transform it into a fully-applied call by wrapping it in a
closure.

Eg,

Foo.bar => { self in { args... self.bar(args...) } }
foo.bar => { self in { args... self.bar(args...) } }(self)

super.bar => { args... in super.bar(args...) }

With this change, SILGen only ever sees fully-applied calls,
which will allow ripping out some code.

This new way of doing curry thunks fixes a long-standing bug
where unbound references to protocol methods did not work.

This is because such a reference must open the existential
*inside* the closure, after 'self' has been applied, whereas
the old SILGen implementation of curry thunks really wanted
the type of the method reference to match the opened type of
the method.

A follow-up cleanup will remove the SILGen curry thunk
implementation.

Fixes rdar://21289579 and https://bugs.swift.org/browse/SR-75.

Author: slavapestov

CHANGELOG.md

@@ -46,6 +46,19 @@ Swift Next
     // OK, <U where U: Equatable> has broader visibility than <T where T == Int>
     override func foo() where U: Equatable { ... } 
   }
+
+* [SR-75][]:
+
+  Unapplied references to protocol methods methods are now supported. Previously this
+  only worked for methods defined in structs, enums and classes.
+
+  ```swift
+  protocol Cat {
+    func play(catToy: Toy)
+  }
+
+  let fn = Cat.play
+  fn(myCat)(myToy)
   ```
 
 * [SE-0266][]:
@@ -7939,6 +7952,7 @@ Swift 1.0
 [SE-0267]: <https://github.com/apple/swift-evolution/blob/master/proposals/0267-where-on-contextually-generic.md>
 [SE-0269]: <https://github.com/apple/swift-evolution/blob/master/proposals/0269-implicit-self-explicit-capture.md>
 
+[SR-75]: <https://bugs.swift.org/browse/SR-75>
 [SR-106]: <https://bugs.swift.org/browse/SR-106>
 [SR-419]: <https://bugs.swift.org/browse/SR-419>
 [SR-631]: <https://bugs.swift.org/browse/SR-631>

lib/SIL/SILDeclRef.cpp

@@ -450,8 +450,11 @@ bool SILDeclRef::isTransparent() const {
   if (isStoredPropertyInitializer())
     return true;
 
-  if (hasAutoClosureExpr())
-    return true;
+  if (hasAutoClosureExpr()) {
+    auto *ace = getAutoClosureExpr();
+    if (ace->getThunkKind() == AutoClosureExpr::Kind::None)
+      return true;
+  }
 
   if (hasDecl()) {
     if (auto *AFD = dyn_cast<AbstractFunctionDecl>(getDecl()))

lib/SIL/SILProfiler.cpp

@@ -68,6 +68,12 @@ static bool isUnmapped(ASTNode N) {
         LLVM_DEBUG(llvm::dbgs() << "Skipping ASTNode: implicit closure expr\n");
         return true;
       }
+
+      if (isa<AutoClosureExpr>(CE) &&
+          cast<AutoClosureExpr>(CE)->getThunkKind() != AutoClosureExpr::Kind::None) {
+        LLVM_DEBUG(llvm::dbgs() << "Skipping ASTNode: curry thunk expr\n");
+        return true;
+      }
     }
 
     // Map all other kinds of expressions.