Sema: Fix archetype vs interface type mixup with type in generic function

Author: slavapestov

include/swift/AST/Types.h

@@ -767,9 +767,12 @@ class alignas(1 << TypeAlignInBits) TypeBase {
 
   /// \brief Retrieve the superclass of this type.
   ///
+  /// \param useArchetypes Whether to use context archetypes for outer generic
+  /// parameters if the class is nested inside a generic function.
+  ///
   /// \returns The superclass of this type, or a null type if it has no
   ///          superclass.
-  Type getSuperclass();
+  Type getSuperclass(bool useArchetypes = true);
 
   /// \brief True if this type is the exact superclass of another type.
   ///
@@ -797,7 +800,11 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   ///
   /// Calling `C<String, NSObject>`->getSuperclassForDecl(`A`) will return
   /// `A<Int, NSObject>`.
-  Type getSuperclassForDecl(const ClassDecl *classDecl);
+  ///
+  /// \param useArchetypes Whether to use context archetypes for outer generic
+  /// parameters if the class is nested inside a generic function.
+  Type getSuperclassForDecl(const ClassDecl *classDecl,
+                            bool useArchetypes = true);
 
   /// \brief Whether this type or its superclasses has some form of generic
   /// context.

lib/AST/Type.cpp

@@ -1461,7 +1461,7 @@ bool TypeBase::satisfiesClassConstraint() {
   return mayHaveSuperclass() || isObjCExistentialType();
 }
 
-Type TypeBase::getSuperclass() {
+Type TypeBase::getSuperclass(bool useArchetypes) {
   auto *nominalDecl = getAnyNominal();
   auto *classDecl = dyn_cast_or_null<ClassDecl>(nominalDecl);
 
@@ -1496,7 +1496,9 @@ Type TypeBase::getSuperclass() {
   ModuleDecl *module = classDecl->getModuleContext();
   auto subMap = getContextSubstitutionMap(module,
                                           classDecl,
-                                          classDecl->getGenericEnvironment());
+                                          (useArchetypes
+                                           ? classDecl->getGenericEnvironment()
+                                           : nullptr));
   return superclassTy.subst(subMap);
 }
 
@@ -3220,7 +3222,8 @@ static Type getConcreteTypeForSuperclassTraversing(Type t) {
   return t;
 }
 
-Type TypeBase::getSuperclassForDecl(const ClassDecl *baseClass) {
+Type TypeBase::getSuperclassForDecl(const ClassDecl *baseClass,
+                                    bool useArchetypes) {
   Type t = getConcreteTypeForSuperclassTraversing(this);
 
   while (t) {
@@ -3233,7 +3236,7 @@ Type TypeBase::getSuperclassForDecl(const ClassDecl *baseClass) {
     if (nominalDecl == baseClass)
       return t;
 
-    t = t->getSuperclass();
+    t = t->getSuperclass(useArchetypes);
   }
   llvm_unreachable("no inheritance relationship between given classes");
 }

lib/Sema/GenericTypeResolver.h

@@ -36,6 +36,8 @@ class GenericTypeResolver {
 public:
   virtual ~GenericTypeResolver();
 
+  virtual bool usesArchetypes() = 0;
+
   /// Resolve the given interface type to a contextual type if necessary.
   virtual Type mapTypeIntoContext(Type type) = 0;
 
@@ -66,6 +68,8 @@ class GenericTypeResolver {
 /// and only trivially resolves dependent member types.
 class DependentGenericTypeResolver : public GenericTypeResolver {
 public:
+  virtual bool usesArchetypes() { return false; }
+
   virtual Type mapTypeIntoContext(Type type);
 
   virtual Type resolveDependentMemberType(Type baseTy,
@@ -93,6 +97,8 @@ class GenericTypeToArchetypeResolver : public GenericTypeResolver {
   explicit GenericTypeToArchetypeResolver(DeclContext *dc)
       : GenericEnv(dc->getGenericEnvironmentOfContext()) { }
 
+  virtual bool usesArchetypes() { return true; }
+
   virtual Type mapTypeIntoContext(Type type);
 
   virtual Type resolveDependentMemberType(Type baseTy, DeclContext *DC,
@@ -111,6 +117,8 @@ class GenericTypeToArchetypeResolver : public GenericTypeResolver {
 /// protocols.
 class ProtocolRequirementTypeResolver : public GenericTypeResolver {
 public:
+  virtual bool usesArchetypes() { return false; }
+
   virtual Type mapTypeIntoContext(Type type);
 
   virtual Type resolveDependentMemberType(Type baseTy, DeclContext *DC,
@@ -137,6 +145,8 @@ class CompleteGenericTypeResolver : public GenericTypeResolver {
 public:
   CompleteGenericTypeResolver(TypeChecker &tc, GenericSignature *genericSig);
 
+  virtual bool usesArchetypes() { return false; }
+
   virtual Type mapTypeIntoContext(Type type);
 
   virtual Type resolveDependentMemberType(Type baseTy,

lib/Sema/TypeCheckType.cpp

@@ -309,7 +309,7 @@ Type TypeChecker::resolveTypeInContext(
 
   // Finally, substitute the base type into the member type.
   return substMemberTypeWithBase(fromDC->getParentModule(), typeDecl,
-                                 selfType);
+                                 selfType, resolver->usesArchetypes());
 }
 
 static TypeResolutionOptions
@@ -3017,14 +3017,15 @@ Type TypeResolver::buildProtocolType(
 
 Type TypeChecker::substMemberTypeWithBase(ModuleDecl *module,
                                           TypeDecl *member,
-                                          Type baseTy) {
+                                          Type baseTy,
+                                          bool useArchetypes) {
   Type sugaredBaseTy = baseTy;
 
   // For type members of a base class, make sure we use the right
   // derived class as the parent type.
   if (auto *ownerClass = member->getDeclContext()
           ->getAsClassOrClassExtensionContext()) {
-    baseTy = baseTy->getSuperclassForDecl(ownerClass);
+    baseTy = baseTy->getSuperclassForDecl(ownerClass, useArchetypes);
   }
 
   if (baseTy->is<ModuleType>()) {

lib/Sema/TypeChecker.h

@@ -1103,7 +1103,10 @@ class TypeChecker final : public LazyResolver {
   /// \param member The member whose type projection is being computed.
   /// \param baseTy The base type that will be substituted for the 'Self' of the
   /// member.
-  Type substMemberTypeWithBase(ModuleDecl *module, TypeDecl *member, Type baseTy);
+  /// \param useArchetypes Whether to use context archetypes for outer generic
+  /// parameters if the class is nested inside a generic function.
+  Type substMemberTypeWithBase(ModuleDecl *module, TypeDecl *member, Type baseTy,
+                              bool useArchetypes = true);
 
   /// \brief Retrieve the superclass type of the given type, or a null type if
   /// the type has no supertype.

test/decl/nested/type_in_function.swift

@@ -147,3 +147,14 @@ func freeFunction() {
     // expected-error@-1 {{can only be used as a generic constraint because it has Self or associated type requirements}}
   }
 }
+
+// Superclass lookup archetype vs interface type mixup
+class Generic<T> {
+  struct Nested {}
+
+  func outerMethod() {
+    class Inner : Generic<T> { // expected-error {{type 'Inner' cannot be nested in generic function 'outerMethod()'}}
+      func innerMethod() -> Nested {}
+    }
+  }
+}

validation-test/compiler_crashers/28836-functy-hasarchetype.swift renamed to validation-test/compiler_crashers_fixed/28836-functy-hasarchetype.swift

@@ -5,6 +5,6 @@
 // See https://swift.org/LICENSE.txt for license information
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 
-// REQUIRES: asserts
-// RUN: not --crash %target-swift-frontend %s -emit-ir
+
+// RUN: not %target-swift-frontend %s -emit-ir
 class a<a{protocol P{}func a{protocol P{class a:a{func a:P