Merge remote-tracking branch 'origin/master' into master-rebranch

Author: swift-ci

lib/AST/ASTContext.cpp

@@ -4408,6 +4408,7 @@ GenericSignature *
 ASTContext::getOverrideGenericSignature(const ValueDecl *base,
                                         const ValueDecl *derived) {
   auto baseGenericCtx = base->getAsGenericContext();
+  auto derivedGenericCtx = derived->getAsGenericContext();
   auto &ctx = base->getASTContext();
 
   if (!baseGenericCtx) {
@@ -4431,6 +4432,10 @@ ASTContext::getOverrideGenericSignature(const ValueDecl *base,
     return nullptr;
   }
 
+  if (!derivedGenericCtx || !derivedGenericCtx->isGeneric()) {
+    return nullptr;
+  }
+
   if (derivedClass->getGenericSignature() == nullptr &&
       !baseGenericCtx->isGeneric()) {
     return nullptr;
@@ -4459,12 +4464,8 @@ ASTContext::getOverrideGenericSignature(const ValueDecl *base,
   GenericSignatureBuilder builder(ctx);
   builder.addGenericSignature(derivedClass->getGenericSignature());
 
-  if (auto derivedGenericCtx = derived->getAsGenericContext()) {
-    if (derivedGenericCtx->isGeneric()) {
-      for (auto param : *derivedGenericCtx->getGenericParams()) {
-        builder.addGenericParameter(param);
-      }
-    }
+  for (auto param : *derivedGenericCtx->getGenericParams()) {
+    builder.addGenericParameter(param);
   }
 
   auto source =

lib/Sema/TypeCheckDeclOverride.cpp

@@ -171,6 +171,22 @@ bool swift::isOverrideBasedOnType(ValueDecl *decl, Type declTy,
   if (declIUOAttr != parentDeclIUOAttr)
     return false;
 
+  // If the generic signatures don't match, then return false because we don't
+  // want to complain if an overridden method matches multiple superclass
+  // methods which differ in generic signature.
+  //
+  // We can still succeed with a subtype match later in
+  // OverrideMatcher::match().
+  auto declGenericCtx = decl->getAsGenericContext();
+  auto &ctx = decl->getASTContext();
+  auto sig = ctx.getOverrideGenericSignature(parentDecl, decl);
+
+  if (sig && declGenericCtx &&
+      declGenericCtx->getGenericSignature()->getCanonicalSignature() !=
+          sig->getCanonicalSignature()) {
+    return false;
+  }
+
   // If this is a constructor, let's compare only parameter types.
   if (isa<ConstructorDecl>(decl)) {
     // Within a protocol context, check for a failability mismatch.

test/attr/attr_override.swift

@@ -597,3 +597,32 @@ class SR_4206_Derived<C: SR_4206_Container> : SR_4206_Base<C.Key> {
   typealias Key = C.Key
   override func foo(forKey key: Key) throws {} // Okay, no generic signature mismatch
 }
+
+// SR-10198
+
+class SR_10198_Base {
+  func a<T>(_ val: T) -> String { return "not equatable" }
+  func a<T: Equatable>(_ val: T) -> String { return "equatable" }
+}
+
+class SR_10198_Derived: SR_10198_Base {
+  override func a<T>(_ val: T) -> String { return super.a(val) } // okay
+  override func a<T: Equatable>(_ val: T) -> String { return super.a(val) } // okay
+}
+
+protocol SR_10198_Base_P {
+  associatedtype Bar
+}
+
+struct SR_10198_Base_S: SR_10198_Base_P {
+  typealias Bar = Int
+}
+
+class SR_10198_Base_1 {
+  init<F: SR_10198_Base_P>(_ arg: F) where F.Bar == Int {}
+}
+
+class SR_10198_Derived_1: SR_10198_Base_1 {
+  init(_ arg1: Int) { super.init(SR_10198_Base_S()) } // okay, doesn't crash
+}
+