[Completion] Handle unbound generics in typealiases

The underlying type for a typealias can be an unbound generic type,
replace these with the bound generic equivalent. This avoids crashing
when attempting to compute the type relation (in the future we'll
want to open these type parameters for the comparison).

rdar://147789214

Author: hamishknight

include/swift/IDE/CompletionLookup.h

@@ -435,6 +435,9 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
   void addNominalTypeRef(const NominalTypeDecl *NTD, DeclVisibilityKind Reason,
                          DynamicLookupInfo dynamicLookupInfo);
 
+  Type getTypeAliasType(const TypeAliasDecl *TAD,
+                        DynamicLookupInfo dynamicLookupInfo);
+
   void addTypeAliasRef(const TypeAliasDecl *TAD, DeclVisibilityKind Reason,
                        DynamicLookupInfo dynamicLookupInfo);
 

lib/IDE/CompletionLookup.cpp

@@ -1755,6 +1755,41 @@ void CompletionLookup::addNominalTypeRef(const NominalTypeDecl *NTD,
   Builder.setTypeContext(expectedTypeContext, CurrDeclContext);
 }
 
+Type CompletionLookup::getTypeAliasType(const TypeAliasDecl *TAD,
+                                        DynamicLookupInfo dynamicLookupInfo) {
+  // Substitute the base type for a nested typealias if needed.
+  auto ty = getTypeOfMember(TAD, dynamicLookupInfo);
+  auto *typeAliasTy = dyn_cast<TypeAliasType>(ty.getPointer());
+  if (!typeAliasTy)
+    return ty;
+
+  // If the underlying type has an error, prefer to print the full typealias,
+  // otherwise get the underlying type.
+  Type underlyingTy = typeAliasTy->getSinglyDesugaredType();
+  if (underlyingTy->hasError())
+    return ty;
+
+  // The underlying type might be unbound for e.g:
+  //
+  // struct S<T> {}
+  // typealias X = S
+  //
+  // Introduce type parameters such that we print the underlying type as
+  // 'S<T>'.
+  return underlyingTy.transformRec([&](TypeBase *ty) -> std::optional<Type> {
+    if (!ty->hasUnboundGenericType()) {
+      // Skip.
+      return ty;
+    }
+    auto *UGT = dyn_cast<UnboundGenericType>(ty);
+    if (!UGT) {
+      // Recurse.
+      return std::nullopt;
+    }
+    return UGT->getDecl()->getDeclaredInterfaceType();
+  });
+}
+
 void CompletionLookup::addTypeAliasRef(const TypeAliasDecl *TAD,
                                        DeclVisibilityKind Reason,
                                        DynamicLookupInfo dynamicLookupInfo) {
@@ -1764,18 +1799,7 @@ void CompletionLookup::addTypeAliasRef(const TypeAliasDecl *TAD,
   Builder.setAssociatedDecl(TAD);
   addLeadingDot(Builder);
   addValueBaseName(Builder, TAD->getBaseName());
-
-  // Substitute the base type for a nested typealias if needed.
-  auto ty = getTypeOfMember(TAD, dynamicLookupInfo);
-
-  // If the underlying type has an error, prefer to print the full typealias,
-  // otherwise get the underlying type.
-  if (auto *TA = dyn_cast<TypeAliasType>(ty.getPointer())) {
-    auto underlyingTy = TA->getSinglyDesugaredType();
-    if (!underlyingTy->hasError())
-      ty = underlyingTy;
-  }
-  addTypeAnnotation(Builder, ty);
+  addTypeAnnotation(Builder, getTypeAliasType(TAD, dynamicLookupInfo));
 }
 
 void CompletionLookup::addGenericTypeParamRef(

test/IDE/complete_rdar147789214.swift

@@ -0,0 +1,30 @@
+// RUN: %batch-code-completion
+
+// rdar://147789214 - Make sure we insert generic parameters for underlying type.
+
+struct S<T> {}
+typealias Foo = S
+typealias Bar = Foo
+typealias Baz<T> = S<T>
+typealias Invalid = (S, S)
+
+let _: S = #^COMPLETE^#
+// COMPLETE-DAG: Decl[TypeAlias]/CurrModule: Foo[#S<T>#]; name=Foo
+// COMPLETE-DAG: Decl[TypeAlias]/CurrModule: Bar[#Foo#]; name=Bar
+// COMPLETE-DAG: Decl[TypeAlias]/CurrModule: Baz[#S<T>#]; name=Baz
+// COMPLETE-DAG: Decl[TypeAlias]/CurrModule: Invalid[#Invalid#]; name=Invalid
+
+struct R<U> {
+  typealias X = S<U>
+  typealias Y = S
+  typealias Z<T> = S<T>
+
+  func foo() {
+    // TODO: Once we start comparing type relations for types with generic
+    // parameters, ideally 'Y' and 'Z' should be convertible, but not 'X'.
+    let _: S<Int> = #^COMPLETE_IN_TYPE^#
+    // COMPLETE_IN_TYPE-DAG: Decl[TypeAlias]/CurrNominal: X[#S<U>#]; name=X
+    // COMPLETE_IN_TYPE-DAG: Decl[TypeAlias]/CurrNominal: Y[#S<T>#]; name=Y
+    // COMPLETE_IN_TYPE-DAG: Decl[TypeAlias]/CurrNominal: Z[#S<T>#]; name=Z
+  }
+}