Merge pull request #77632 from slavapestov/subst-map-verify

Flush out incorrectly-constructed substitution maps

Author: slavapestov

include/swift/AST/SubstitutionMap.h

@@ -213,8 +213,9 @@ class SubstitutionMap {
   /// interface types.
   SubstitutionMap mapReplacementTypesOutOfContext() const;
 
-  /// Verify that this substitution map is valid.
-  void verify() const;
+  /// Verify that the conformances stored in this substitution map match the
+  /// replacement types provided.
+  void verify(bool allowInvalid=true) const;
 
   /// Whether to dump the full substitution map, or just a minimal useful subset
   /// (on a single line).

lib/AST/ProtocolConformance.cpp

@@ -976,8 +976,7 @@ ProtocolConformance::subst(InFlightSubstitution &IFS) const {
   switch (getKind()) {
   case ProtocolConformanceKind::Normal: {
     auto origType = getType();
-    if (!origType->hasTypeParameter() &&
-        !origType->hasArchetype())
+    if (IFS.isInvariant(origType))
       return ProtocolConformanceRef(mutableThis);
 
     auto substType = origType.subst(IFS);
@@ -998,8 +997,7 @@ ProtocolConformance::subst(InFlightSubstitution &IFS) const {
 
   case ProtocolConformanceKind::Builtin: {
     auto origType = getType();
-    if (!origType->hasTypeParameter() &&
-        !origType->hasArchetype())
+    if (IFS.isInvariant(origType))
       return ProtocolConformanceRef(mutableThis);
 
     auto substType = origType.subst(IFS);
@@ -1022,18 +1020,14 @@ ProtocolConformance::subst(InFlightSubstitution &IFS) const {
 
   case ProtocolConformanceKind::Inherited: {
     // Substitute the base.
-    auto inheritedConformance
-      = cast<InheritedProtocolConformance>(this)->getInheritedConformance();
-
     auto origType = getType();
-    if (!origType->hasTypeParameter() &&
-        !origType->hasArchetype()) {
+    if (IFS.isInvariant(origType))
       return ProtocolConformanceRef(mutableThis);
-    }
 
-    auto origBaseType = inheritedConformance->getType();
-    if (origBaseType->hasTypeParameter() ||
-        origBaseType->hasArchetype()) {
+    auto inheritedConformance
+      = cast<InheritedProtocolConformance>(this)->getInheritedConformance();
+
+    if (!IFS.isInvariant(inheritedConformance->getType())) {
       // Substitute into the superclass.
       auto substConformance = inheritedConformance->subst(IFS);
       if (!substConformance.isConcrete())

lib/AST/RequirementEnvironment.cpp

@@ -118,28 +118,41 @@ RequirementEnvironment::RequirementEnvironment(
       }
       return substGenericParam;
     },
-    [selfType, substConcreteType, conformance, conformanceDC, &ctx](
+    [selfType, substConcreteType, conformance, conformanceDC, covariantSelf, &ctx](
         CanType type, Type replacement, ProtocolDecl *proto)
           -> ProtocolConformanceRef {
       // The protocol 'Self' conforms concretely to the conforming type.
       if (type->isEqual(selfType)) {
-        ProtocolConformance *specialized = conformance;
-        if (conformance && conformance->getGenericSignature()) {
-          auto concreteSubs =
-            substConcreteType->getContextSubstitutionMap(conformanceDC);
-          specialized =
-            ctx.getSpecializedConformance(substConcreteType,
-                                          cast<NormalProtocolConformance>(conformance),
-                                          concreteSubs);
-        }
+        ASSERT(covariantSelf || replacement->isEqual(substConcreteType));
+
+        if (conformance) {
+          ProtocolConformance *specialized = conformance;
+
+          if (conformance->getGenericSignature()) {
+            auto concreteSubs =
+              substConcreteType->getContextSubstitutionMap(conformanceDC);
+            specialized =
+              ctx.getSpecializedConformance(substConcreteType,
+                                            cast<NormalProtocolConformance>(conformance),
+                                            concreteSubs);
+          }
+
+          // findWitnessedObjCRequirements() does a weird thing by passing in a
+          // DC that is not the conformance DC. Work around it here.
+          if (!specialized->getType()->isEqual(replacement)) {
+            ASSERT(specialized->getType()->isExactSuperclassOf(substConcreteType));
+            ASSERT(covariantSelf ? replacement->is<GenericTypeParamType>()
+                                 : replacement->isEqual(substConcreteType));
+            specialized = ctx.getInheritedConformance(replacement, specialized);
+          }
 
-        if (specialized)
           return ProtocolConformanceRef(specialized);
+        }
       }
 
       // All other generic parameters come from the requirement itself
       // and conform abstractly.
-      return ProtocolConformanceRef(proto);
+      return MakeAbstractConformanceForGenericType()(type, replacement, proto);
     });
 
   // If the requirement itself is non-generic, the witness thunk signature

lib/AST/SubstitutionMap.cpp

@@ -60,10 +60,8 @@ SubstitutionMap::SubstitutionMap(
                                 ArrayRef<Type> replacementTypes,
                                 ArrayRef<ProtocolConformanceRef> conformances)
   : storage(Storage::get(genericSig, replacementTypes, conformances)) {
-#ifndef NDEBUG
   if (genericSig->getASTContext().LangOpts.VerifyAllSubstitutionMaps)
     verify();
-#endif
 }
 
 ArrayRef<ProtocolConformanceRef> SubstitutionMap::getConformances() const {
@@ -534,78 +532,109 @@ SubstitutionMap::getOverrideSubstitutions(const NominalTypeDecl *baseNominal,
              LookUpConformanceInOverrideSubs(info));
 }
 
-void SubstitutionMap::verify() const {
-#ifndef NDEBUG
+void SubstitutionMap::verify(bool allowInvalid) const {
   if (empty())
     return;
 
+  auto genericSig = getGenericSignature();
+  auto &ctx = genericSig->getASTContext();
+
+  if (ctx.isRecursivelyConstructingRequirementMachine(
+        genericSig.getCanonicalSignature()))
+    return;
+
   unsigned conformanceIndex = 0;
 
-  for (const auto &req : getGenericSignature().getRequirements()) {
+  for (const auto &req : genericSig.getRequirements()) {
     if (req.getKind() != RequirementKind::Conformance)
       continue;
 
     SWIFT_DEFER { ++conformanceIndex; };
+    auto conformance = getConformances()[conformanceIndex];
+
     auto substType = req.getFirstType().subst(*this);
-    if (substType->isTypeParameter() ||
-        substType->is<ArchetypeType>() ||
-        substType->isTypeVariableOrMember() ||
-        substType->is<UnresolvedType>() ||
-        substType->hasError())
-      continue;
 
-    auto conformance = getConformances()[conformanceIndex];
+    // Unwrap various strange things.
+    substType = substType->getReferenceStorageReferent();
+    if (auto *selfType = substType->getAs<DynamicSelfType>())
+      substType = selfType->getSelfType();
 
-    if (conformance.isInvalid())
-      continue;
+    // Don't bother validating these cases.
+    if (allowInvalid && substType->hasUnboundGenericType())
+      return;
+
+    if (conformance.isInvalid()) {
+      if (!allowInvalid) {
+        llvm::errs() << "Unexpected invalid conformance in substitution map:\n";
+        dump(llvm::dbgs());
+        llvm::errs() << "\n";
+        abort();
+      }
 
-    // All of the conformances should be concrete.
-    if (!conformance.isConcrete()) {
-      llvm::dbgs() << "Concrete type cannot have abstract conformance:\n";
-      substType->dump(llvm::dbgs());
-      llvm::dbgs() << "SubstitutionMap:\n";
-      dump(llvm::dbgs());
-      llvm::dbgs() << "\n";
-      llvm::dbgs() << "Requirement:\n";
-      req.dump(llvm::dbgs());
-      llvm::dbgs() << "\n";
+      continue;
     }
-    assert(conformance.isConcrete() && "Conformance should be concrete");
-    
-    if (substType->is<UnboundGenericType>())
+
+    if (conformance.isAbstract()) {
+      if (!substType->isTypeParameter() &&
+          !substType->is<PackElementType>() &&
+          !substType->is<ArchetypeType>() &&
+          !substType->isTypeVariableOrMember() &&
+          !substType->is<UnresolvedType>() &&
+          !substType->is<PlaceholderType>() &&
+          !substType->is<ErrorType>()) {
+        llvm::errs() << "Unexpected abstract conformance in substitution map:\n";
+        dump(llvm::errs());
+        llvm::errs() << "\n";
+        abort();
+      }
+
       continue;
-    
-    auto conformanceTy = conformance.getConcrete()->getType();
-    if (conformanceTy->hasTypeParameter()
-        && !substType->hasTypeParameter()) {
-      conformanceTy = conformance.getConcrete()->getDeclContext()
-        ->mapTypeIntoContext(conformanceTy);
     }
-    
-    if (!substType->isEqual(conformanceTy)) {
-      llvm::dbgs() << "Conformance must match concrete replacement type:\n";
-      substType->dump(llvm::dbgs());
-      llvm::dbgs() << "Conformance type:\n";
-      conformance.getConcrete()->getType()->dump(llvm::dbgs());
-      llvm::dbgs() << "Conformance:\n";
-      conformance.dump(llvm::dbgs());
-      llvm::dbgs() << "\n";
-      llvm::dbgs() << "SubstitutionMap:\n";
-      dump(llvm::dbgs());
-      llvm::dbgs() << "\n";
-      llvm::dbgs() << "Requirement:\n";
-      req.dump(llvm::dbgs());
-      llvm::dbgs() << "\n";
+
+    if (conformance.isPack()) {
+      // FIXME: Implement some kind of check here.
+      continue;
     }
-    assert(substType->isEqual(conformanceTy)
-           && "conformance should match corresponding type");
+
+    auto *concrete = conformance.getConcrete();
 
     if (substType->isExistentialType()) {
-      assert(isa<SelfProtocolConformance>(conformance.getConcrete()) &&
-              "Existential type cannot have normal conformance");
+      if (req.getProtocolDecl()->isSpecificProtocol(KnownProtocolKind::Sendable) &&
+          isa<BuiltinProtocolConformance>(concrete)) {
+        continue;
+      }
+
+      if (!isa<SelfProtocolConformance>(concrete)) {
+        // A superclass-constrained self-conforming existential might conform
+        // concretely.
+        if (substType->getSuperclass())
+          continue;
+
+        llvm::errs() << "Expected to find a self conformance:\n";
+        substType->dump(llvm::errs());
+        llvm::errs() << "Substitution map:\n";
+        dump(llvm::errs());
+        llvm::errs() << "\n";
+        abort();
+      }
+
+      continue;
+    }
+
+    if (substType->isTypeParameter())
+      continue;
+
+    if (!concrete->getType()->isEqual(substType)) {
+      llvm::errs() << "Conformance with wrong conforming type:\n";
+      concrete->getType()->dump(llvm::errs());
+      llvm::errs() << "Should be:\n";
+      substType->dump(llvm::errs());
+      llvm::errs() << "Substitution map:\n";
+      dump(llvm::errs());
+      llvm::errs() << "\n";
+      abort();
     }
   }
-#endif
 }
 
 void SubstitutionMap::profile(llvm::FoldingSetNodeID &id) const {

lib/SILGen/ResultPlan.cpp

@@ -772,6 +772,9 @@ class ForeignAsyncInitializationPlan final : public ResultPlan {
       auto createIntrinsic =
           throws ? SGF.SGM.getCreateCheckedThrowingContinuation()
                  : SGF.SGM.getCreateCheckedContinuation();
+    auto conformances =
+        collectExistentialConformances(calleeTypeInfo.substResultType,
+                                       ctx.TheAnyType);
       auto subs =
           SubstitutionMap::get(createIntrinsic->getGenericSignature(),
                                {calleeTypeInfo.substResultType}, conformances);

lib/SILGen/SILGenPoly.cpp

@@ -5438,7 +5438,10 @@ CanSILFunctionType SILGenFunction::buildThunkType(
     SubstitutionMap &interfaceSubs,
     CanType &dynamicSelfType,
     bool withoutActuallyEscaping) {
-  return buildSILFunctionThunkType(&F, sourceType, expectedType, inputSubstType, outputSubstType, genericEnv, interfaceSubs, dynamicSelfType, withoutActuallyEscaping);
+  return buildSILFunctionThunkType(
+      &F, sourceType, expectedType, inputSubstType, outputSubstType,
+      genericEnv, interfaceSubs, dynamicSelfType,
+      withoutActuallyEscaping);
 }
 
 static ManagedValue createPartialApplyOfThunk(SILGenFunction &SGF,
@@ -7227,8 +7230,7 @@ void SILGenFunction::emitProtocolWitness(
     auto deallocCleanup = std::get<3>(tokenAndCleanups);
 
     YieldInfo witnessYieldInfo(SGM, witness, witnessFTy, witnessSubs);
-    YieldInfo reqtYieldInfo(SGM, requirement, thunkTy,
-                            reqtSubs.subst(getForwardingSubstitutionMap()));
+    YieldInfo reqtYieldInfo(SGM, requirement, thunkTy, reqtSubs);
 
     translateYields(*this, loc, witnessYields, witnessYieldInfo, reqtYieldInfo);
 

lib/SILGen/SILGenType.cpp

@@ -752,13 +752,6 @@ SILFunction *SILGenModule::emitProtocolWitness(
     reqtOrigTy->substGenericArgs(reqtSubMap)
       ->getReducedType(genericSig));
 
-  // Generic signatures where all parameters are concrete are lowered away
-  // at the SILFunctionType level.
-  if (genericSig && genericSig->areAllParamsConcrete()) {
-    genericSig = nullptr;
-    genericEnv = nullptr;
-  }
-
   // Rewrite the conformance in terms of the requirement environment's Self
   // type, which might have a different generic signature than the type
   // itself.
@@ -772,6 +765,16 @@ SILFunction *SILGenModule::emitProtocolWitness(
     auto self = requirement->getSelfInterfaceType()->getCanonicalType();
 
     conformance = reqtSubMap.lookupConformance(self, requirement);
+
+    if (genericEnv)
+      reqtSubMap = reqtSubMap.subst(genericEnv->getForwardingSubstitutionMap());
+  }
+
+  // Generic signatures where all parameters are concrete are lowered away
+  // at the SILFunctionType level.
+  if (genericSig && genericSig->areAllParamsConcrete()) {
+    genericSig = nullptr;
+    genericEnv = nullptr;
   }
 
   reqtSubstTy =
@@ -794,6 +797,15 @@ SILFunction *SILGenModule::emitProtocolWitness(
     }
   }
 
+  ProtocolConformance *manglingConformance = nullptr;
+  if (conformance.isConcrete()) {
+    manglingConformance = conformance.getConcrete();
+    if (auto *inherited = dyn_cast<InheritedProtocolConformance>(manglingConformance)) {
+      manglingConformance = inherited->getInheritedConformance();
+      conformance = ProtocolConformanceRef(manglingConformance);
+    }
+  }
+
   // Lower the witness thunk type with the requirement's abstraction level.
   auto witnessSILFnType = getNativeSILFunctionType(
       M.Types, TypeExpansionContext::minimal(), AbstractionPattern(reqtOrigTy),
@@ -802,8 +814,6 @@ SILFunction *SILGenModule::emitProtocolWitness(
 
   // Mangle the name of the witness thunk.
   Mangle::ASTMangler NewMangler;
-  auto manglingConformance =
-      conformance.isConcrete() ? conformance.getConcrete() : nullptr;
   std::string nameBuffer =
       NewMangler.mangleWitnessThunk(manglingConformance, requirement.getDecl());
   // TODO(TF-685): Proper mangling for derivative witness thunks.

lib/SILOptimizer/Utils/Generics.cpp

@@ -3137,7 +3137,7 @@ static bool usePrespecialized(
 
       auto newSubstMap = SubstitutionMap::get(
           apply.getSubstitutionMap().getGenericSignature(), newSubs,
-          apply.getSubstitutionMap().getConformances());
+          LookUpConformanceInModule());
 
       ReabstractionInfo layoutReInfo = ReabstractionInfo(
           funcBuilder.getModule().getSwiftModule(),