Sema: New TypeBase::adjustSuperclassMemberDeclType() method

This generalizes some code in Sema to fix the problem where
generic method overrides don't work if the base class is
more or less generic than the derived class.

The problem here was that we were checking types for equality
when matching overrides, which failed if generic parameters
had different depths. Now, map the generic parameters of the
base class member to the generic signature of the derived
member, so that the equality check can succeed.

Since SIL type lowering needs to perform a similar check,
move this from Sema to a method on TypeBase to complement
the existing getTypeOfMember().

Note that getTypeOfMember() still does a superclass walk, but
ideally this will go away soon.

Author: slavapestov

include/swift/AST/Types.h

@@ -866,6 +866,14 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   Type getTypeOfMember(ModuleDecl *module, Type memberType,
                        const DeclContext *memberDC);
 
+  /// Get the type of a superclass member as seen from the subclass,
+  /// substituting generic parameters, dynamic Self return, and the
+  /// 'self' argument type as appropriate.
+  Type adjustSuperclassMemberDeclType(const ValueDecl *decl,
+                                      const ValueDecl *parentDecl,
+                                      Type memberType,
+                                      LazyResolver *resolver);
+
   /// Return T if this type is Optional<T>; otherwise, return the null type.
   Type getOptionalObjectType();
 

lib/AST/Type.cpp

@@ -3053,14 +3053,56 @@ Type TypeBase::getTypeOfMember(Module *module, Type memberType,
     return memberType;
 
   // Compute the set of member substitutions to apply.
-  TypeSubstitutionMap substitutions = getMemberSubstitutions(memberDC);
+  auto substitutions = getMemberSubstitutions(memberDC);
   if (substitutions.empty())
     return memberType;
 
   // Perform the substitutions.
   return memberType.subst(module, substitutions, None);
 }
 
+Type TypeBase::adjustSuperclassMemberDeclType(const ValueDecl *decl,
+                                              const ValueDecl *parentDecl,
+                                              Type memberType,
+                                              LazyResolver *resolver) {
+  auto *DC = parentDecl->getDeclContext();
+  auto superclass = getSuperclassForDecl(
+      DC->getAsClassOrClassExtensionContext(), resolver);
+  auto subs = superclass->getMemberSubstitutions(DC);
+
+  if (auto *parentFunc = dyn_cast<AbstractFunctionDecl>(parentDecl)) {
+    if (auto *func = dyn_cast<AbstractFunctionDecl>(decl)) {
+      auto *genericParams = func->getGenericParams();
+      auto *parentParams = parentFunc->getGenericParams();
+      if (genericParams && parentParams &&
+          genericParams->size() == parentParams->size()) {
+        for (unsigned i = 0, e = genericParams->size(); i < e; i++) {
+          auto paramTy = parentParams->getParams()[i]->getDeclaredInterfaceType()
+              ->getCanonicalType().getPointer();
+          subs[paramTy] = genericParams->getParams()[i]
+              ->getDeclaredInterfaceType();
+        }
+      }
+    }
+  }
+
+  auto type = memberType.subst(parentDecl->getModuleContext(), subs);
+
+  if (isa<AbstractFunctionDecl>(parentDecl)) {
+    type = type->replaceSelfParameterType(this);
+    if (auto func = dyn_cast<FuncDecl>(parentDecl)) {
+      if (func->hasDynamicSelf()) {
+        type = type->replaceCovariantResultType(this,
+                                                func->getNumParameterLists());
+      }
+    } else if (isa<ConstructorDecl>(parentDecl)) {
+      type = type->replaceCovariantResultType(this, /*uncurryLevel=*/2);
+    }
+  }
+
+  return type;
+}
+
 Identifier DependentMemberType::getName() const {
   if (NameOrAssocType.is<Identifier>())
     return NameOrAssocType.get<Identifier>();

lib/Sema/TypeCheckDecl.cpp

@@ -5014,32 +5014,6 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
   void visitModuleDecl(ModuleDecl *) { }
 
-  /// Adjust the type of the given declaration to appear as if it were
-  /// in the given subclass of its actual declared class.
-  static Type adjustSuperclassMemberDeclType(TypeChecker &TC,
-                                             const ValueDecl *decl,
-                                             Type subclass) {
-    ClassDecl *superclassDecl =
-      decl->getDeclContext()->getDeclaredTypeInContext()
-        ->getClassOrBoundGenericClass();
-    auto superclass = subclass;
-    while (superclass->getClassOrBoundGenericClass() != superclassDecl)
-      superclass = TC.getSuperClassOf(superclass);
-    auto type = TC.substMemberTypeWithBase(decl->getModuleContext(), decl,
-                                           superclass,
-                                           /*isTypeReference=*/false);
-    if (auto func = dyn_cast<FuncDecl>(decl)) {
-      if (func->hasDynamicSelf()) {
-        type = type->replaceCovariantResultType(subclass,
-                                                func->getNumParameterLists());
-      }
-    } else if (isa<ConstructorDecl>(decl)) {
-      type = type->replaceCovariantResultType(subclass, /*uncurryLevel=*/2);
-    }
-
-    return type;
-  }
-
   /// Perform basic checking to determine whether a declaration can override a
   /// declaration in a superclass.
   static bool areOverrideCompatibleSimple(ValueDecl *decl,
@@ -5093,15 +5067,15 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
   static bool
   diagnoseMismatchedOptionals(TypeChecker &TC,
-                              const Decl *member,
+                              const ValueDecl *member,
                               const ParameterList *params,
                               TypeLoc resultTL,
                               const ValueDecl *parentMember,
                               Type owningTy,
                               bool treatIUOResultAsError) {
     bool emittedError = false;
-    Type plainParentTy = adjustSuperclassMemberDeclType(TC, parentMember,
-                                                        owningTy);
+    Type plainParentTy = owningTy->adjustSuperclassMemberDeclType(
+        member, parentMember, parentMember->getInterfaceType(), &TC);
     const auto *parentTy = plainParentTy->castTo<AnyFunctionType>();
     if (isa<AbstractFunctionDecl>(parentMember))
       parentTy = parentTy->getResult()->castTo<AnyFunctionType>();
@@ -5538,8 +5512,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
         // Check whether the types are identical.
         // FIXME: It's wrong to use the uncurried types here for methods.
-        auto parentDeclTy = adjustSuperclassMemberDeclType(TC, parentDecl,
-                                                           owningTy);
+        auto parentDeclTy = owningTy->adjustSuperclassMemberDeclType(
+            decl, parentDecl, parentDecl->getInterfaceType(), &TC);
         parentDeclTy = parentDeclTy->getUnlabeledType(TC.Context);
         if (method) {
           parentDeclTy = parentDeclTy->castTo<AnyFunctionType>()->getResult();
@@ -5807,8 +5781,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         }
       } else if (auto property = dyn_cast_or_null<VarDecl>(abstractStorage)) {
         auto propertyTy = property->getInterfaceType();
-        auto parentPropertyTy = adjustSuperclassMemberDeclType(TC, matchDecl,
-                                                               superclass);
+        auto parentPropertyTy = superclass->adjustSuperclassMemberDeclType(
+            decl, matchDecl, matchDecl->getInterfaceType(), &TC);
 
         if (!propertyTy->canOverride(parentPropertyTy,
                                      OverrideMatchMode::Strict,