Sema: Visit types of captures to determine if a closure captures the generic signature

Otherwise, we can miss that 'self' has a generic type when accessed
via a 'super' call if the type of 'super' is concrete.

This is a regression from a patch series to allow C function pointers
to be formed from closures in generic contexts -- basically, the
check was not conservative enough, and in this case, it would
conclude the closure did not capture the generic signature when
in reality it did:

533f42d

Fixes <rdar://problem/25439564>.

Author: slavapestov

lib/Sema/TypeCheckExpr.cpp

@@ -812,6 +812,13 @@ namespace {
         captureList[entryNumber-1] = capture;
       }
 
+      // Visit the type of the capture. If we capture 'self' via a 'super' call,
+      // and the superclass is not generic, there might not be any generic
+      // parameter types in the closure body, so we have to account for them
+      // here.
+      if (VD->hasType())
+        checkType(VD->getType());
+
       // If VD is a noescape decl, then the closure we're computing this for
       // must also be noescape.
       if (VD->getAttrs().hasAttribute<NoEscapeAttr>() &&

test/SILGen/closures.swift

@@ -564,3 +564,25 @@ class UnownedSelfNestedCapture {
     {[unowned self] in { self } }()()
   }
 }
+
+// Check that capturing 'self' via a 'super' call also captures the generic
+// signature if the base class is concrete and the derived class is generic
+
+class ConcreteBase {
+  func swim() {}
+}
+
+// CHECK-LABEL: sil shared @_TFFC8closures14GenericDerived4swimFT_T_U_FT_T_ : $@convention(thin) <Ocean> (@owned GenericDerived<Ocean>) -> ()
+// CHECK:         [[SUPER:%.*]] = upcast %0 : $GenericDerived<Ocean> to $ConcreteBase
+// CHECK:         [[METHOD:%.*]] = function_ref @_TFC8closures12ConcreteBase4swimfT_T_
+// CHECK:         apply [[METHOD]]([[SUPER]]) : $@convention(method) (@guaranteed ConcreteBase) -> ()
+
+class GenericDerived<Ocean> : ConcreteBase {
+  override func swim() {
+    withFlotationAid {
+      super.swim()
+    }
+  }
+
+  func withFlotationAid(fn: () -> ()) {}
+}