[Sema] Fix compiler error when extending a typealias of a partially specialized generic type

lib/Sema/TypeCheckDecl.cpp

@@ -3012,6 +3012,42 @@ AllMembersRequest::evaluate(
   return evaluateMembersRequest(idc, MembersRequestKind::All);
 }
 
+static bool isTypeInferredByTypealias(TypeAliasDecl *typealias,
+                                            NominalTypeDecl *nominal) {
+  bool isInferredType = false;
+
+  if (!nominal->isGeneric()){
+    return false;
+  }
+
+  auto nominalGenericArguments = nominal->getDeclaredInterfaceType()
+                                     .getPointer()
+                                     ->getAs<BoundGenericType>()
+                                     ->getGenericArgs();
+  auto typealiasGenericArguments = typealias->getUnderlyingType()
+                                       .getPointer()
+                                       ->getAs<BoundGenericType>()
+                                       ->getGenericArgs();
+
+  for (size_t i = 0; i < nominalGenericArguments.size(); i++) {
+    auto nominalBoundGenericType = nominalGenericArguments[i];
+    auto typealiasBoundGenericType = typealiasGenericArguments[i];
+    if (nominalBoundGenericType.getPointer()->isEqual(
+            typealiasBoundGenericType.getPointer())) {
+      continue;
+    }
+
+    if (!typealiasBoundGenericType->hasTypeParameter()) {
+      isInferredType = true;
+    } else {
+      isInferredType = false;
+      break;
+    }
+  }
+
+  return isInferredType;
+}
+
 bool TypeChecker::isPassThroughTypealias(TypeAliasDecl *typealias,
                                          NominalTypeDecl *nominal) {
   // Pass-through only makes sense when the typealias refers to a nominal
@@ -3020,6 +3056,7 @@ bool TypeChecker::isPassThroughTypealias(TypeAliasDecl *typealias,
 
   // Check that the nominal type and the typealias are either both generic
   // at this level or neither are.
+  ASSERT(nominal->isGeneric() == typealias->isGeneric());
   if (nominal->isGeneric() != typealias->isGeneric())
     return false;
 
@@ -3032,17 +3069,41 @@ bool TypeChecker::isPassThroughTypealias(TypeAliasDecl *typealias,
   // If neither is generic, we're done: it's a pass-through alias.
   if (!nominalSig) return true;
 
-  // Check that the type parameters are the same the whole way through.
   auto nominalGenericParams = nominalSig.getGenericParams();
   auto typealiasGenericParams = typealiasSig.getGenericParams();
-  if (nominalGenericParams.size() != typealiasGenericParams.size())
-    return false;
-  if (!std::equal(nominalGenericParams.begin(), nominalGenericParams.end(),
-                  typealiasGenericParams.begin(),
-                  [](GenericTypeParamType *gp1, GenericTypeParamType *gp2) {
-                    return gp1->isEqual(gp2);
-                  }))
-    return false;
+
+  if (nominalGenericParams.size() != typealiasGenericParams.size()) {
+
+    unsigned nominalMaxDepth = nominalGenericParams.back()->getDepth();
+    unsigned typealiasMaxDepth = typealiasGenericParams.back()->getDepth();
+    unsigned maxDepth = std::max(nominalMaxDepth, typealiasMaxDepth);
+
+    for (const auto &type : nominalGenericParams) {
+      if (type->getDepth() == maxDepth) {
+        nominalGenericParams = nominalGenericParams.drop_back();
+      }
+    }
+
+    for (const auto &type : typealiasGenericParams) {
+      if (type->getDepth() == maxDepth) {
+        typealiasGenericParams = typealiasGenericParams.drop_back();
+      }
+    }
+
+    if (nominalGenericParams.size() != typealiasGenericParams.size()) {
+      return false;
+    }
+
+    if (!std::equal(nominalGenericParams.begin(), nominalGenericParams.end(),
+                    typealiasGenericParams.begin(),
+                    [](GenericTypeParamType *gp1, GenericTypeParamType *gp2) {
+                      return gp1->isEqual(gp2);
+                    })) {
+      return false;
+    }
+
+    return isTypeInferredByTypealias(typealias, nominal);
+  }
 
   // If neither is generic at this level, we have a pass-through typealias.
   if (!typealias->isGeneric()) return true;

test/decl/ext/specialize.swift

@@ -32,6 +32,66 @@ extension IntFoo where U == Int {
 
 Foo(x: "test", y: 1).hello()
 
+
+struct Field<Tag,Value> {
+  let tag: Tag
+  let value: Value
+}
+
+typealias IntField<Tag> = Field<Tag,Int>
+
+extension IntField {
+  func adding(_ value: Int) -> Self {
+    Field(tag: tag, value: self.value + value)
+  }
+}
+
+struct S<X, Y> {}
+typealias InferredSpecializedNestedTypes<X> = S<X, (Int, [Int]?)>
+extension InferredSpecializedNestedTypes {
+    func returnTuple(value: Y) -> (Int, [Int]?) {
+        return value
+    }
+}
+
+
+struct S2<X,Y,Z> {
+  let x: X
+  let y: Y
+  let z: Z
+}
+
+typealias A2<Y,X> = S2<Int,X,Y>
+
+extension A2 {
+  func adding(_ x: Int) -> Self {
+    S2(x: self.x + x, y: y, z: z) // expected-error {{binary operator '+' cannot be applied to operands of type 'X' and 'Int'}} expected-note {{overloads for '+' exist with these partially matching parameter lists: (Int, Int)}}
+  }
+}
+
+
+struct S4<A, B> {
+  // Generic parameters: <A, B, C>
+  // Depth:               0  0  1
+  struct Nested<C> {
+      let c: C
+  }
+}
+
+struct S5<A> {
+  // Generic parameters: <A, B, C>
+  // Depth:               0  1  1
+  typealias Alias<B, C> = S4<A, B>.Nested<C>
+
+}
+
+extension S5.Alias{
+  func adding(_ c: Int) -> Self {
+        S4.Nested(c: self.c + c) //expected-error {{binary operator '+' cannot be applied to operands of type 'C' and 'Int'}} expected-note {{overloads for '+' exist with these partially matching parameter lists: (Int, Int)}}
+    }
+}
+
+
 struct MyType<TyA, TyB> {
   var a : TyA, b : TyB
 }