Sema: Fix problems with checkTypeWitness()

Our tentative witness might have weird concrete DependentMemberTypes
in it. In that case, perform a more relaxed check that can succeed
as long as the witness is not completely invalid.

This problem was exposed by existing test cases starting to fail
once implicit Copyable requirements were introduced, because these
concrete DependentMemberTypes do not conform to protocols. This now
postpones the check until all witnesses have been fully substituted.

This also fixes a long-standing bug with superclass requirements on
associated types.

Fixes #48770,
#51772,
rdar://95729075.

Author: slavapestov

include/swift/AST/DiagnosticsSema.def

@@ -2905,11 +2905,6 @@ NOTE(default_associated_type_unsatisfied_superclass,none,
      "default type %0 for associated type %1 (from protocol %2) "
      "does not inherit from %3",
      (Type, const AssociatedTypeDecl *, Type, Type))
-NOTE(default_associated_type_tuple,none,
-     "default type %0 for associated type %1 (from protocol %2) "
-     "is unsuitable for tuple conformance; the associated type requirement "
-     "must be fulfilled by a type alias with underlying type %3",
-     (Type, const AssociatedTypeDecl *, Type, Type))
 ERROR(associated_type_access,none,
       "associated type in "
       "%select{a private|a fileprivate|an internal|a package|a public|%error}0 protocol "
@@ -2945,11 +2940,6 @@ NOTE(associated_type_deduction_unsatisfied_superclass,none,
      "candidate would match and infer %0 = %1 if %1 "
      "inherited from %2",
      (const AssociatedTypeDecl *, Type, Type))
-NOTE(associated_type_deduction_tuple,none,
-     "cannot infer %0 = %1 in tuple conformance because "
-     "the associated type requirement must be fulfilled by a type alias with "
-     "underlying type %2",
-     (const AssociatedTypeDecl *, Type, Type))
 NOTE(associated_type_witness_conform_impossible,none,
      "candidate can not infer %0 = %1 because %1 "
      "is not a nominal type and so can't conform to %2",

lib/Sema/AssociatedTypeInference.cpp

@@ -87,11 +87,7 @@ class CheckTypeWitnessResult {
 
     /// Type witness does not satisfy a layout requirement on
     /// the associated type.
-    Layout,
-
-    /// Type witness of a tuple conformance does not have the form
-    /// (repeat (each Element).A).
-    Tuple
+    Layout
   } kind;
 
 private:
@@ -125,25 +121,36 @@ class CheckTypeWitnessResult {
     return CheckTypeWitnessResult(Layout, reqt);
   }
 
-  static CheckTypeWitnessResult forTuple(Type reqt) {
-    return CheckTypeWitnessResult(Tuple, reqt);
-  }
-
   Kind getKind() const { return kind; }
   Type getRequirement() const { return reqt; }
 
   explicit operator bool() const { return kind != Success; }
 };
 
+/// Checks a potential witness for an associated type A against the "local"
+/// requirements of the type parameter Self.[P]A. We call this to check
+/// type witnesses found by name lookup, as well as candidate witnesses during
+/// inference.
+///
+/// This does not completely check the witness; we check the entire requirement
+/// signature at the end. However, rejecting witnesses that are definitely
+/// invalid here can cut down the search space.
 static CheckTypeWitnessResult
 checkTypeWitness(Type type, AssociatedTypeDecl *assocType,
                  const NormalProtocolConformance *Conf,
                  SubstOptions options) {
+  assert(!type->hasTypeParameter());
+
   auto &ctx = assocType->getASTContext();
 
   if (type->hasError())
     return CheckTypeWitnessResult::forError();
 
+  // If the type witness is equivalent to some other unresolved witness,
+  // we cannot check anything, so accept the witness.
+  if (type->is<DependentMemberType>())
+    return CheckTypeWitnessResult::forSuccess();
+
   const auto proto = Conf->getProtocol();
   const auto dc = Conf->getDeclContext();
   const auto sig = proto->getGenericSignature();
@@ -167,53 +174,43 @@ checkTypeWitness(Type type, AssociatedTypeDecl *assocType,
   const auto depTy = DependentMemberType::get(proto->getSelfInterfaceType(),
                                               assocType);
 
-  Type contextType = type->hasTypeParameter() ? dc->mapTypeIntoContext(type)
-                                              : type;
-
   if (auto superclass = sig->getSuperclassBound(depTy)) {
-    if (superclass->hasTypeParameter()) {
-      // Replace type parameters with other known or tentative type witnesses.
-      superclass = superclass.subst(
-          [&](SubstitutableType *type) {
-            if (type->isEqual(proto->getSelfInterfaceType()))
-              return Conf->getType();
-
-            return Type();
-          },
-          LookUpConformanceInModule(dc->getParentModule()), options);
-
-      if (superclass->hasTypeParameter())
-        superclass = dc->mapTypeIntoContext(superclass);
+    // We only check that the type's superclass declaration is correct.
+    // If the superclass bound is generic, we may not have resolved all of
+    // the type witnesses that appear in generic arguments yet, and doing so
+    // here might run into a request cycle.
+    auto superclassDecl = superclass->getClassOrBoundGenericClass();
+    assert(superclassDecl);
+
+    // Fish a class declaration out of the type witness.
+    auto classDecl = type->getClassOrBoundGenericClass();
+    if (!classDecl) {
+      if (auto archetype = type->getAs<ArchetypeType>()) {
+        if (auto superclassType = archetype->getSuperclass())
+          classDecl = superclassType->getClassOrBoundGenericClass();
+      }
     }
-    if (!superclass->isExactSuperclassOf(contextType))
+
+    if (!classDecl || !superclassDecl->isSuperclassOf(classDecl))
       return CheckTypeWitnessResult::forSuperclass(superclass);
   }
 
   auto *module = dc->getParentModule();
 
-  // Check protocol conformances.
+  // Check protocol conformances. We don't check conditional requirements here.
   for (const auto reqProto : sig->getRequiredProtocols(depTy)) {
     if (module->lookupConformance(
-            contextType, reqProto,
+            type, reqProto,
             /*allowMissing=*/reqProto->isSpecificProtocol(
                 KnownProtocolKind::Sendable))
             .isInvalid())
       return CheckTypeWitnessResult::forConformance(reqProto);
   }
 
+  // We can completely check an AnyObject layout constraint.
   if (sig->requiresClass(depTy) &&
-      !contextType->satisfiesClassConstraint()) {
-    return CheckTypeWitnessResult::forLayout(
-        module->getASTContext().getAnyObjectType());
-  }
-
-  // Tuple conformances can only witness associated types by projecting them
-  // element-wise.
-  if (isa<BuiltinTupleDecl>(dc->getSelfNominalTypeDecl())) {
-    auto expectedTy = getTupleConformanceTypeWitness(dc, assocType);
-    if (!expectedTy->isEqual(type)) {
-      return CheckTypeWitnessResult::forTuple(expectedTy);
-    }
+      !type->satisfiesClassConstraint()) {
+    return CheckTypeWitnessResult::forLayout(ctx.getAnyObjectType());
   }
 
   // Success!
@@ -222,10 +219,21 @@ checkTypeWitness(Type type, AssociatedTypeDecl *assocType,
 
 }
 
+static bool containsConcreteDependentMemberType(Type ty) {
+  return ty.findIf([](Type t) -> bool {
+    if (auto *dmt = t->getAs<DependentMemberType>())
+      return !dmt->isTypeParameter();
+
+    return false;
+  });
+}
+
 static void recordTypeWitness(NormalProtocolConformance *conformance,
                               AssociatedTypeDecl *assocType,
                               Type type,
                               TypeDecl *typeDecl) {
+  assert(!containsConcreteDependentMemberType(type));
+
   // If we already recoded this type witness, there's nothing to do.
   if (conformance->hasTypeWitness(assocType)) {
     assert(conformance->getTypeWitnessUncached(assocType)
@@ -473,9 +481,12 @@ static ResolveWitnessResult resolveTypeWitnessViaLookup(
     if (!viableTypes.insert(memberType->getCanonicalType()).second)
       continue;
 
+    auto memberTypeInContext = dc->mapTypeIntoContext(memberType);
+
     // Check this type against the protocol requirements.
     if (auto checkResult =
-            checkTypeWitness(memberType, assocType, conformance, llvm::None)) {
+            checkTypeWitness(memberTypeInContext, assocType,
+                             conformance, llvm::None)) {
       nonViable.push_back({typeDecl, checkResult});
     } else {
       viable.push_back({typeDecl, memberType, nullptr});
@@ -551,14 +562,6 @@ static ResolveWitnessResult resolveTypeWitnessViaLookup(
              candidate.first->getDeclaredInterfaceType(),
              candidate.second.getRequirement());
           break;
-
-        case CheckTypeWitnessResult::Tuple:
-          diags.diagnose(
-             candidate.first,
-             diag::protocol_type_witness_tuple,
-             candidate.first->getDeclaredInterfaceType(),
-             candidate.second.getRequirement());
-          break;
         }
       }
     });
@@ -1353,7 +1356,6 @@ enum class InferenceCandidateKind {
 
 static InferenceCandidateKind checkInferenceCandidate(
     std::pair<AssociatedTypeDecl *, Type> *result,
-    bool *canInferFromOtherAssociatedType,
     NormalProtocolConformance *conformance,
     ValueDecl *witness) {
   auto isTautological = [&](Type t) -> bool {
@@ -1418,7 +1420,6 @@ static InferenceCandidateKind checkInferenceCandidate(
                   return otherDMT;
                 return t;
               });
-              *canInferFromOtherAssociatedType = true;
               LLVM_DEBUG(llvm::dbgs() << "++ we can same-type to:\n";
                          result->second->dump(llvm::dbgs()));
               return InferenceCandidateKind::Good;
@@ -1543,11 +1544,7 @@ AssociatedTypeInference::getPotentialTypeWitnessesFromRequirement(
       // Filter out circular possibilities, e.g. that
       // AssocType == S.AssocType or
       // AssocType == Foo<S.AssocType>.
-      bool canInferFromOtherAssociatedType = false;
-
-      switch (checkInferenceCandidate(&result,
-                                      &canInferFromOtherAssociatedType,
-                                      conformance, witness)) {
+      switch (checkInferenceCandidate(&result, conformance, witness)) {
       case InferenceCandidateKind::Good:
         // Continued below.
         break;
@@ -1588,23 +1585,19 @@ AssociatedTypeInference::getPotentialTypeWitnessesFromRequirement(
         }
       }
 
-      // If we same-typed to another unresolved associated type, we won't
-      // be able to check conformances yet.
-      if (!canInferFromOtherAssociatedType) {
-        // Check that the type witness meets the
-        // requirements on the associated type.
-        if (auto failed =
-                checkTypeWitness(result.second, result.first, conformance,
-                                 llvm::None)) {
-          witnessResult.NonViable.push_back(
-                          std::make_tuple(result.first,result.second,failed));
-          LLVM_DEBUG(llvm::dbgs() << "-- doesn't fulfill requirements\n");
-
-          // By adding an element to NonViable we ensure the witness is rejected
-          // below, so we continue to consider other bindings to generate better
-          // diagnostics later.
-          REJECT;
-        }
+      // Check that the type witness meets the requirements on the
+      // associated type.
+      if (auto failed =
+              checkTypeWitness(result.second, result.first, conformance,
+                               llvm::None)) {
+        witnessResult.NonViable.push_back(
+                        std::make_tuple(result.first,result.second,failed));
+        LLVM_DEBUG(llvm::dbgs() << "-- doesn't fulfill requirements\n");
+
+        // By adding an element to NonViable we ensure the witness is rejected
+        // below, so we continue to consider other bindings to generate better
+        // diagnostics later.
+        REJECT;
       }
 
       LLVM_DEBUG(llvm::dbgs() << "++ seems legit\n");
@@ -2286,6 +2279,8 @@ AssociatedTypeInference::computeDerivedTypeWitness(
   if (!result.first)
     return std::make_pair(Type(), nullptr);
 
+  assert(!containsConcreteDependentMemberType(result.first));
+
   // Make sure that the derived type satisfies requirements.
   if (checkTypeWitness(result.first, assocType, conformance, llvm::None)) {
     /// FIXME: Diagnose based on this.
@@ -2649,15 +2644,6 @@ bool AssociatedTypeInference::checkConstrainedExtension(ExtensionDecl *ext) {
   llvm_unreachable("unhandled result");
 }
 
-static bool containsConcreteDependentMemberType(Type ty) {
-  return ty.findIf([](Type t) -> bool {
-    if (auto *dmt = t->getAs<DependentMemberType>())
-      return !dmt->isTypeParameter();
-
-    return false;
-  });
-}
-
 AssociatedTypeDecl *AssociatedTypeInference::inferAbstractTypeWitnesses(
     ArrayRef<AssociatedTypeDecl *> unresolvedAssocTypes, unsigned reqDepth) {
   if (unresolvedAssocTypes.empty()) {
@@ -3560,16 +3546,6 @@ bool AssociatedTypeInference::diagnoseNoSolutions(
              proto->getDeclaredInterfaceType(),
              failedDefaultedResult.getRequirement());
           break;
-
-        case CheckTypeWitnessResult::Tuple:
-          diags.diagnose(
-             failedDefaultedAssocType,
-             diag::default_associated_type_tuple,
-             failedDefaultedWitness,
-             failedDefaultedAssocType,
-             proto->getDeclaredInterfaceType(),
-             failedDefaultedResult.getRequirement());
-          break;
         }
       });
 
@@ -3675,14 +3651,6 @@ bool AssociatedTypeInference::diagnoseNoSolutions(
                assocType, failed.TypeWitness,
                failed.Result.getRequirement());
             break;
-
-          case CheckTypeWitnessResult::Tuple:
-            diags.diagnose(
-               failed.Witness,
-               diag::associated_type_deduction_tuple,
-               assocType, failed.TypeWitness,
-               failed.Result.getRequirement());
-            break;
           }
         }
       });

lib/Sema/TypeCheckProtocol.cpp

@@ -3456,7 +3456,7 @@ static bool isNSObjectProtocol(ProtocolDecl *proto) {
   return proto->hasClangNode();
 }
 
-Type swift::getTupleConformanceTypeWitness(DeclContext *dc,
+static Type getTupleConformanceTypeWitness(DeclContext *dc,
                                            AssociatedTypeDecl *assocType) {
   auto genericSig = dc->getGenericSignatureOfContext();
   assert(genericSig.getGenericParams().size() == 1);
@@ -4751,16 +4751,29 @@ static void ensureRequirementsAreSatisfied(ASTContext &ctx,
     return;
   }
 
-  // Now check that our associated conformances are at least as visible as
-  // the conformance itself.
+  bool isTupleConformance = isa<BuiltinTupleDecl>(dc->getSelfNominalTypeDecl());
+
   auto where = ExportContext::forConformance(dc, proto);
-  if (where.isImplicit())
-    return;
 
   conformance->forEachTypeWitness([&](AssociatedTypeDecl *assocType,
                                       Type type, TypeDecl *typeDecl) -> bool {
     checkObjCTypeErasedGenerics(conformance, assocType, type, typeDecl);
 
+    // Tuple conformances can only witness associated types by projecting them
+    // element-wise.
+    if (isTupleConformance) {
+      auto expectedTy = getTupleConformanceTypeWitness(dc, assocType);
+      if (!type->hasError() && !expectedTy->isEqual(type)) {
+        ctx.addDelayedConformanceDiag(conformance, true,
+              [dc, type, typeDecl, expectedTy](NormalProtocolConformance *conformance) {
+          dc->getASTContext().Diags.diagnose(
+              getLocForDiagnosingWitness(conformance, typeDecl),
+              diag::protocol_type_witness_tuple,
+              type, expectedTy);
+        });
+      }
+    }
+
     if (typeDecl && !typeDecl->isImplicit()) {
       auto requiredAccessScope = evaluateOrDefault(
           ctx.evaluator, ConformanceAccessScopeRequest{dc, proto},
@@ -4808,6 +4821,11 @@ static void ensureRequirementsAreSatisfied(ASTContext &ctx,
     return false;
   });
 
+  // Now check that our associated conformances are at least as visible as
+  // the conformance itself.
+  if (where.isImplicit())
+    return;
+
   conformance->forEachAssociatedConformance(
     [&](Type depTy, ProtocolDecl *proto, unsigned index) {
       auto assocConf = conformance->getAssociatedConformance(depTy, proto);

lib/Sema/TypeCheckProtocol.h

@@ -218,9 +218,6 @@ void diagnoseConformanceFailure(Type T,
                                 DeclContext *DC,
                                 SourceLoc ComplainLoc);
 
-Type getTupleConformanceTypeWitness(DeclContext *dc,
-                                    AssociatedTypeDecl *assocType);
-
 /// Find an associated type declaration that provides a default definition.
 AssociatedTypeDecl *findDefaultedAssociatedType(
     DeclContext *dc, NominalTypeDecl *adoptee,