Merge pull request #60833 from slavapestov/fix-rdar98404650

AST: Work around shortcoming in abstract conformance representation when computing override substitutions

Author: slavapestov

include/swift/AST/ASTContext.h

@@ -1255,7 +1255,7 @@ class ASTContext final {
   /// \param type The type for which we are retrieving the conformance.
   ///
   /// \param inherited The inherited conformance.
-  InheritedProtocolConformance *
+  ProtocolConformance *
   getInheritedConformance(Type type, ProtocolConformance *inherited);
 
   /// Get the lazy data for the given declaration.

lib/AST/ASTContext.cpp

@@ -2448,30 +2448,39 @@ ASTContext::getSpecializedConformance(Type type,
   return result;
 }
 
-InheritedProtocolConformance *
+ProtocolConformance *
 ASTContext::getInheritedConformance(Type type, ProtocolConformance *inherited) {
   // Collapse multiple levels of inherited conformance.
-  while (auto *otherInherited = dyn_cast<InheritedProtocolConformance>(inherited))
+  if (auto *otherInherited = dyn_cast<InheritedProtocolConformance>(inherited))
     inherited = otherInherited->getInheritedConformance();
 
   assert(isa<SpecializedProtocolConformance>(inherited) ||
          isa<NormalProtocolConformance>(inherited) ||
          isa<BuiltinProtocolConformance>(inherited));
 
+  // Collapse useless inherited conformances. Conformance lookup with aa
+  // archetype T that has a superclass bound C will return a concrete
+  // conformance if C conforms to the protocol P. This is wrapped in an
+  // inherited conformance with the archetype type T. If you then substitute
+  // T := C, you don't want to form an inherited conformance with a type of
+  // C, because the underlying conformance already has a type of C.
+  if (inherited->getType()->isEqual(type))
+    return inherited;
+
   llvm::FoldingSetNodeID id;
   InheritedProtocolConformance::Profile(id, type, inherited);
 
   // Figure out which arena this conformance should go into.
   AllocationArena arena = getArena(type->getRecursiveProperties());
 
-  // Did we already record the normal protocol conformance?
+  // Did we already record the inherited protocol conformance?
   void *insertPos;
   auto &inheritedConformances = getImpl().getArena(arena).InheritedConformances;
   if (auto result
         = inheritedConformances.FindNodeOrInsertPos(id, insertPos))
     return result;
 
-  // Build a new normal protocol conformance.
+  // Build a new inherited protocol conformance.
   auto result = new (*this, arena) InheritedProtocolConformance(type, inherited);
   inheritedConformances.InsertNode(result, insertPos);
   return result;

lib/AST/SubstitutionMap.cpp

@@ -534,10 +534,25 @@ OverrideSubsInfo::OverrideSubsInfo(const NominalTypeDecl *baseNominal,
   if (auto baseNominalSig = baseNominal->getGenericSignature()) {
     BaseDepth = baseNominalSig.getGenericParams().back()->getDepth() + 1;
 
+    auto *genericEnv = derivedNominal->getGenericEnvironment();
     auto derivedNominalTy = derivedNominal->getDeclaredInterfaceType();
+
+    // FIXME: Map in and out of context to get more accurate
+    // conformance information. If the base generic signature
+    // is <T: P> and the derived generic signature is <T: C>
+    // where C is a class that conforms to P, then we want the
+    // substitution map to store the concrete conformance C: P
+    // and not the abstract conformance T: P.
+    if (genericEnv) {
+      derivedNominalTy = genericEnv->mapTypeIntoContext(
+          derivedNominalTy);
+    }
+
     BaseSubMap = derivedNominalTy->getContextSubstitutionMap(
-        baseNominal->getParentModule(), baseNominal);
-    assert(!BaseSubMap.hasArchetypes());
+        baseNominal->getParentModule(), baseNominal,
+        genericEnv);
+
+    BaseSubMap = BaseSubMap.mapReplacementTypesOutOfContext();
   }
 
   if (auto derivedNominalSig = derivedNominal->getGenericSignature())

lib/AST/Type.cpp

@@ -4886,11 +4886,15 @@ TypeBase::getContextSubstitutions(const DeclContext *dc,
     break;
   }
 
+  // Add any outer generic parameters from the local context.
   while (n > 0) {
     auto *gp = params[--n];
-    auto substTy = (genericEnv
-                    ? genericEnv->mapTypeIntoContext(gp)
-                    : gp);
+    Type substTy = gp;
+    if (baseTy && baseTy->is<ErrorType>())
+      substTy = ErrorType::get(baseTy->getASTContext());
+    else if (genericEnv)
+      substTy = genericEnv->mapTypeIntoContext(gp);
+
     auto result = substitutions.insert(
       {gp->getCanonicalType()->castTo<GenericTypeParamType>(),
        substTy});

test/SILGen/default_arguments_inherited_generic.swift

@@ -0,0 +1,16 @@
+// RUN: %target-swift-emit-silgen %s | %FileCheck %s
+
+class Base<T: P> {
+  init(x: Int = 0) {}
+}
+
+class Derived<T: C> : Base<T> {}
+
+protocol P {}
+class C: P {}
+
+_ = Derived<C>()
+
+// CHECK-LABEL: sil [ossa] @main : $@convention(c) (Int32, UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>) -> Int32 {
+// CHECK: [[FN:%.*]] = function_ref @$s35default_arguments_inherited_generic4BaseC1xACyxGSi_tcfcfA_ : $@convention(thin) <τ_0_0 where τ_0_0 : P> () -> Int
+// CHECK: apply [[FN]]<C>() : $@convention(thin) <τ_0_0 where τ_0_0 : P> () -> Int