Sema: Fix getTypeOfMemberReference() for unbound instance methods

Always rewrite the Self type to the base type. Previously we only
did it if the method had a dynamic self return. This caused some
confusing behavior in this case:

class C {
  func m1() {}
  func m2() -> Self {}
}
class D : C {}

The types of D.m1 and D.m2 are:
- D.m1: C -> () -> ()
- D.m2: D -> () -> D

For protocols, this also meant that the type of an instance method
reference P.f had an open existential that could "leak out" of
the OpenExistentialExpr. Now, P.f will have type P -> ... -> ...,
however using such a reference still crashes, just in SILGen
instead of Sema, because we don't generate the right thunks yet.

Progress on <rdar://problem/21289579>.

Swift SVN r29447

Author: slavapestov

lib/Sema/ConstraintSystem.cpp

@@ -1205,11 +1205,13 @@ ConstraintSystem::getTypeOfMemberReference(Type baseTy, ValueDecl *value,
   }
 
   // If we are looking at a member of an existential, open the existential.
+  Type baseOpenedTy = baseObjTy;
+
   if (baseObjTy->isExistentialType()) {
     ArchetypeType *openedArchetype = ArchetypeType::getOpened(baseObjTy);
     OpenedExistentialTypes.push_back({ getConstraintLocator(locator),
                                        openedArchetype });
-    baseObjTy = openedArchetype;
+    baseOpenedTy = openedArchetype;
   }
 
   // Constrain the 'self' object type.
@@ -1219,10 +1221,10 @@ ConstraintSystem::getTypeOfMemberReference(Type baseTy, ValueDecl *value,
     // For a protocol, substitute the base object directly. We don't need a
     // conformance constraint because we wouldn't have found the declaration
     // if it didn't conform.
-    addConstraint(ConstraintKind::Equal, baseObjTy, selfObjTy,
+    addConstraint(ConstraintKind::Equal, baseOpenedTy, selfObjTy,
                   getConstraintLocator(locator));
   } else if (!isDynamicResult) {
-    addSelfConstraint(*this, baseObjTy, selfObjTy, locator);
+    addSelfConstraint(*this, baseOpenedTy, selfObjTy, locator);
   }
 
   // Compute the type of the reference.
@@ -1248,23 +1250,19 @@ ConstraintSystem::getTypeOfMemberReference(Type baseTy, ValueDecl *value,
     auto assocType = cast<AssociatedTypeDecl>(value);
 
     type = openedFnType->getResult();
-    if (baseObjTy->is<ArchetypeType>()) {
+    if (baseOpenedTy->is<ArchetypeType>()) {
       // For an archetype, we substitute the base object for the base.
       // FIXME: Feels like a total hack.
-    } else if (!baseObjTy->isExistentialType() &&
-               !baseObjTy->is<ArchetypeType>()) {
+    } else if (!baseOpenedTy->isExistentialType() &&
+               !baseOpenedTy->is<ArchetypeType>()) {
       ProtocolConformance *conformance = nullptr;
-      if (TC.conformsToProtocol(baseObjTy, proto, DC,
+      if (TC.conformsToProtocol(baseOpenedTy, proto, DC,
                                 ConformanceCheckFlags::InExpression,
                                 &conformance)) {
         type = conformance->getTypeWitness(assocType, &TC).getReplacement();
       }
     }
-  } else if (isa<ConstructorDecl>(value) || isa<EnumElementDecl>(value) ||
-             (isa<FuncDecl>(value) && cast<FuncDecl>(value)->isStatic()) ||
-             (isa<VarDecl>(value) && cast<VarDecl>(value)->isStatic()) ||
-             isa<TypeDecl>(value) ||
-             isInstance) {
+  } else if (!value->isInstanceMember() || isInstance) {
     // For a constructor, enum element, static method, static property,
     // or an instance method referenced through an instance, we've consumed the
     // curried 'self' already. For a type, strip off the 'self' we artificially
@@ -1280,18 +1278,12 @@ ConstraintSystem::getTypeOfMemberReference(Type baseTy, ValueDecl *value,
                      ->getDeclaredTypeOfContext();
     type = FunctionType::get(inputTy, resultTy, funcTy->getExtInfo());
   } else {
-    type = openedType;
-
-    // If we're referencing a method with dynamic Self that has 'self'
-    // curried, replace the type of 'self' with the actual base object
-    // type.
-    if (hasDynamicSelf) {
-      auto fnType = type->castTo<FunctionType>();
-      auto selfTy = rebuildSelfTypeWithObjectType(fnType->getInput(), 
-                                                  baseObjTy);      
-      type = FunctionType::get(selfTy, fnType->getResult(),
-                               fnType->getExtInfo());
-    }
+    // For an unbound instance method reference, replace the 'Self'
+    // parameter with the base type.
+    auto selfTy = rebuildSelfTypeWithObjectType(openedFnType->getInput(),
+                                                baseObjTy);
+    type = FunctionType::get(selfTy, openedFnType->getResult(),
+                             openedFnType->getExtInfo());
   }
 
   // If we opened up any type variables, record the replacements.

test/NameBinding/name_lookup.swift

@@ -223,9 +223,13 @@ class ThisDerived1 : ThisBase1 {
     self.baseInstanceVar = 42 // expected-error {{'ThisDerived1.Type' does not have a member named 'baseInstanceVar'}}
     self.baseProp = 42 // expected-error {{'ThisDerived1.Type' does not have a member named 'baseProp'}}
     self.baseFunc0() // expected-error {{missing argument}}
-    self.baseFunc0(ThisBase1())()
+    // FIXME: crappy diagnostic
+    self.baseFunc0(ThisBase1())() // expected-error {{unable to infer closure type in the current context}}
+    self.baseFunc0(ThisDerived1())()
     self.baseFunc1(42) // expected-error {{cannot invoke 'baseFunc1' with an argument list of type '(Int)'}}
-    self.baseFunc1(ThisBase1())(42)
+    // FIXME: crappy diagnostic
+    self.baseFunc1(ThisBase1())(42) // expected-error {{unexpected trailing closure}}
+    self.baseFunc1(ThisDerived1())(42)
     self[0] = 42.0 // expected-error {{'ThisDerived1.Type' does not have a member named 'subscript'}}
     self.baseStaticVar = 42
     self.baseStaticProp = 42