[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,45 @@ 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. We only want the direct underlying type,
+  // not the full desugared type, since that more faithfully reflects what's
+  // written in source.
+  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>'. We only expect unbound generics at the top-level of a type-alias,
+  // they are rejected by type resolution in any other position.
+  //
+  // FIXME: This is a hack – using the declared interface type isn't correct
+  // since the generic parameters ought to be introduced at a higher depth,
+  // i.e we should be treating it as `typealias X<T> = S<T>`. Ideally this would
+  // be fixed by desugaring the unbound typealias during type resolution. For
+  // now this is fine though since we only use the resulting type for printing
+  // the type annotation; the type relation logic currently skips type
+  // parameters.
+  if (auto *UGT = underlyingTy->getAs<UnboundGenericType>())
+    underlyingTy = UGT->getDecl()->getDeclaredInterfaceType();
+
+  ASSERT(!underlyingTy->hasUnboundGenericType());
+  return underlyingTy;
+}
+
 void CompletionLookup::addTypeAliasRef(const TypeAliasDecl *TAD,
                                        DeclVisibilityKind Reason,
                                        DynamicLookupInfo dynamicLookupInfo) {
@@ -1764,18 +1803,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,36 @@
+// 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)
+
+struct Q<T> {
+  struct S<U> {}
+}
+typealias Invalid2 = R<K>.S
+
+let _: S = #^COMPLETE^#
+// COMPLETE-DAG: Decl[TypeAlias]/CurrModule: Foo[#S<T>#]; name=Foo
+// COMPLETE-DAG: Decl[TypeAlias]/CurrModule: Bar[#S<T>#]; name=Bar
+// COMPLETE-DAG: Decl[TypeAlias]/CurrModule: Baz[#S<T>#]; name=Baz
+// COMPLETE-DAG: Decl[TypeAlias]/CurrModule: Invalid[#Invalid#]; name=Invalid
+// COMPLETE-DAG: Decl[TypeAlias]/CurrModule: Invalid2[#Invalid2#]; name=Invalid2
+
+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
+  }
+}