Sema: Allow re-declarations of typealiases in constrained extensions with different generic signatures

Associated type inference will synthesize typealiases in
constrained extensions for conditional conformances, but
then we might later flag them as re-declarations.

Let's not do this, since name lookup does check if generic
requirements are satisfied, so such redeclarations are not
in fact erroneous.

Fixes <rdar://problem/68933045>.

Author: slavapestov

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -565,20 +565,22 @@ CheckRedeclarationRequest::evaluate(Evaluator &eval, ValueDecl *current) const {
     if (current == other || (other->hasInterfaceType() && other->isInvalid()))
       continue;
 
+    auto *otherDC = other->getDeclContext();
+
     // Skip declarations in other modules.
-    if (currentModule != other->getModuleContext())
+    if (currentModule != otherDC->getParentModule())
       continue;
 
     // If both declarations are in the same file, only diagnose the second one.
-    if (currentFile == other->getDeclContext()->getParentSourceFile())
+    if (currentFile == otherDC->getParentSourceFile())
       if (current->getLoc().isValid() &&
           ctx.SourceMgr.isBeforeInBuffer(
             current->getLoc(), other->getLoc()))
         continue;
 
     // Don't compare methods vs. non-methods (which only happens with
     // operators).
-    if (currentDC->isTypeContext() != other->getDeclContext()->isTypeContext())
+    if (currentDC->isTypeContext() != otherDC->isTypeContext())
       continue;
 
     // In local context, only consider exact name matches.
@@ -592,7 +594,7 @@ CheckRedeclarationRequest::evaluate(Evaluator &eval, ValueDecl *current) const {
     if (!conflicting(currentSig, otherSig))
       continue;
 
-    // Skip declarations in other files.
+    // Skip inaccessible declarations in other files.
     // In practice, this means we will warn on a private declaration that
     // shadows a non-private one, but only in the file where the shadowing
     // happens. We will warn on conflicting non-private declarations in both
@@ -605,6 +607,15 @@ CheckRedeclarationRequest::evaluate(Evaluator &eval, ValueDecl *current) const {
     if (other->isInvalid())
       continue;
 
+    // Allow redeclarations of typealiases in different constrained
+    // extensions.
+    if (isa<TypeAliasDecl>(current) &&
+        isa<TypeAliasDecl>(other) &&
+        currentDC != otherDC &&
+        currentDC->getGenericSignatureOfContext().getCanonicalSignature() !=
+        otherDC->getGenericSignatureOfContext().getCanonicalSignature())
+      continue;
+
     // Thwart attempts to override the same declaration more than once.
     const auto *currentOverride = current->getOverriddenDecl();
     const auto *otherOverride = other->getOverriddenDecl();

test/decl/protocol/req/missing_conformance.swift

@@ -132,7 +132,7 @@ extension CountSteps1 // expected-error {{type 'CountSteps1<T>' does not conform
      where T : Equatable
 {
   typealias Index = Int
-  // expected-error@-1 {{invalid redeclaration of synthesized implementation for protocol requirement 'Index'}}
+
   func index(_ i: Index, offsetBy d: Int) -> Index {
     return i + d
   }

test/decl/typealias/redeclaration.swift

@@ -0,0 +1,45 @@
+// RUN: %target-typecheck-verify-swift
+
+struct NonGenericStruct {
+  typealias Horse = Int // expected-note {{'Horse' previously declared here}}
+  typealias Horse = String // expected-error {{invalid redeclaration of 'Horse'}}
+}
+
+struct NonGenericExtendedStruct {}
+
+extension NonGenericExtendedStruct {
+  typealias Horse = Int // expected-note {{'Horse' previously declared here}}
+}
+
+extension NonGenericExtendedStruct {
+  typealias Horse = String // expected-error {{invalid redeclaration of 'Horse'}}
+}
+
+struct GenericStruct<T> {
+  typealias Horse = Int // expected-note {{'Horse' previously declared here}}
+  typealias Horse = String // expected-error {{invalid redeclaration of 'Horse'}}
+}
+
+struct GenericExtendedStruct<T> {}
+
+extension GenericExtendedStruct {
+  typealias Horse = Int // expected-note {{'Horse' previously declared here}}
+}
+
+extension GenericExtendedStruct {
+  typealias Horse = String // expected-error {{invalid redeclaration of 'Horse'}}
+}
+
+struct GenericConstrainedExtendedStruct<T> {}
+
+protocol SomeProtocol {}
+
+extension GenericConstrainedExtendedStruct where T : SomeProtocol {
+  typealias Horse = Int
+}
+
+protocol OtherProtocol {}
+
+extension GenericConstrainedExtendedStruct where T : OtherProtocol {
+  typealias Horse = String // This is OK!
+}