Sema: Ensure archetypes don't leak through when a local generic function uses a typealias defined in function scope

When resolving a typealias, we need to feed it through the resolver
even if it is not defined in type context. For example,

func outer<T>(t: T) {
  typealias TT = T

  // We want 'TT' to resolve to the interface type and not the
  // archetype while we are building inner()'s generic signature
  func inner<U>(t: TT, u: U) {}
}

Author: slavapestov

lib/Sema/GenericTypeResolver.h

@@ -27,6 +27,7 @@ class ArchetypeBuilder;
 class AssociatedTypeDecl;
 class Identifier;
 class TypeChecker;
+class TypeDecl;
 
 /// Abstract class that resolves references into generic types during
 /// type resolution.
@@ -77,6 +78,14 @@ class GenericTypeResolver {
   ///
   /// \returns the type of context.
   virtual Type resolveTypeOfContext(DeclContext *dc) = 0;
+
+  /// Retrieve the type when referring to the given type declaration within
+  /// its context.
+  ///
+  /// \param decl A type declaration.
+  ///
+  /// \returns the type of the declaration in context..
+  virtual Type resolveTypeOfDecl(TypeDecl *decl) = 0;
 };
 
 /// Generic type resolver that leaves all generic types dependent.
@@ -102,6 +111,8 @@ class DependentGenericTypeResolver : public GenericTypeResolver {
                                          AssociatedTypeDecl *assocType);
 
   virtual Type resolveTypeOfContext(DeclContext *dc);
+
+  virtual Type resolveTypeOfDecl(TypeDecl *decl);
 };
 
 /// Generic type resolver that maps a generic type parameter type to its
@@ -123,6 +134,7 @@ class GenericTypeToArchetypeResolver : public GenericTypeResolver {
 
   virtual Type resolveTypeOfContext(DeclContext *dc);
 
+  virtual Type resolveTypeOfDecl(TypeDecl *decl);
 };
 
 /// Generic type resolver that maps any generic type parameter type that
@@ -152,6 +164,8 @@ class PartialGenericTypeToArchetypeResolver : public GenericTypeResolver {
                                          AssociatedTypeDecl *assocType);
 
   virtual Type resolveTypeOfContext(DeclContext *dc);
+
+  virtual Type resolveTypeOfDecl(TypeDecl *decl);
 };
 
 /// Generic type resolver that performs complete resolution of dependent
@@ -181,6 +195,8 @@ class CompleteGenericTypeResolver : public GenericTypeResolver {
                                          AssociatedTypeDecl *assocType);
 
   virtual Type resolveTypeOfContext(DeclContext *dc);
+
+  virtual Type resolveTypeOfDecl(TypeDecl *decl);
 };
 
 } // end namespace swift

lib/Sema/TypeCheckGeneric.cpp

@@ -59,6 +59,10 @@ Type DependentGenericTypeResolver::resolveTypeOfContext(DeclContext *dc) {
   return ext->getExtendedType()->getAnyNominal()->getDeclaredInterfaceType();
 }
 
+Type DependentGenericTypeResolver::resolveTypeOfDecl(TypeDecl *decl) {
+  return decl->getDeclaredInterfaceType();
+}
+
 Type GenericTypeToArchetypeResolver::resolveGenericTypeParamType(
                                        GenericTypeParamType *gp) {
   auto gpDecl = gp->getDecl();
@@ -90,6 +94,10 @@ Type GenericTypeToArchetypeResolver::resolveTypeOfContext(DeclContext *dc) {
   return dc->getDeclaredTypeInContext();
 }
 
+Type GenericTypeToArchetypeResolver::resolveTypeOfDecl(TypeDecl *decl) {
+  return decl->getDeclaredType();
+}
+
 Type PartialGenericTypeToArchetypeResolver::resolveGenericTypeParamType(
                                               GenericTypeParamType *gp) {
   auto gpDecl = gp->getDecl();
@@ -129,6 +137,11 @@ PartialGenericTypeToArchetypeResolver::resolveTypeOfContext(DeclContext *dc) {
   return dc->getDeclaredTypeInContext();
 }
 
+Type
+PartialGenericTypeToArchetypeResolver::resolveTypeOfDecl(TypeDecl *decl) {
+  return decl->getDeclaredType();
+}
+
 Type CompleteGenericTypeResolver::resolveGenericTypeParamType(
                                               GenericTypeParamType *gp) {
   // Retrieve the potential archetype corresponding to this generic type
@@ -223,6 +236,10 @@ Type CompleteGenericTypeResolver::resolveTypeOfContext(DeclContext *dc) {
   return ext->getExtendedType()->getAnyNominal()->getDeclaredInterfaceType();
 }
 
+Type CompleteGenericTypeResolver::resolveTypeOfDecl(TypeDecl *decl) {
+  return decl->getDeclaredInterfaceType();
+}
+
 /// Check the generic parameters in the given generic parameter list (and its
 /// parent generic parameter lists) according to the given resolver.
 bool TypeChecker::checkGenericParamList(ArchetypeBuilder *builder,

lib/Sema/TypeCheckType.cpp

@@ -249,8 +249,18 @@ Type TypeChecker::resolveTypeInContext(
       nominalType = nullptr;
     }
 
-    if (nonTypeOwner)
+    if (nonTypeOwner) {
+      // If this is a typealias not in type context, we still need the
+      // interface type; the typealias might be in a function context, and
+      // its underlying type might reference outer generic parameters.
+      if (isa<TypeAliasDecl>(typeDecl))
+        return resolver->resolveTypeOfDecl(typeDecl);
+
+      // When a nominal type used outside its context, return the unbound
+      // generic form of the type.
+      assert(isa<NominalTypeDecl>(typeDecl) || isa<ModuleDecl>(typeDecl));
       return typeDecl->getDeclaredType();
+    }
 
     // For the next steps we need our parentDC to be a type context
     if (!parentDC->isTypeContext())