Sema: Refactor CheckTypeWitnessResult type used in conformance checking

Author: slavapestov

lib/Sema/TypeCheckProtocol.cpp

@@ -4613,7 +4613,7 @@ swift::checkTypeWitness(Type type, AssociatedTypeDecl *assocType,
   auto &ctx = assocType->getASTContext();
 
   if (type->hasError())
-    return ErrorType::get(ctx);
+    return CheckTypeWitnessResult::forError();
 
   const auto proto = Conf->getProtocol();
   const auto dc = Conf->getDeclContext();
@@ -4624,14 +4624,14 @@ swift::checkTypeWitness(Type type, AssociatedTypeDecl *assocType,
   if (ctx.isRecursivelyConstructingRequirementMachine(sig.getCanonicalSignature()) ||
       ctx.isRecursivelyConstructingRequirementMachine(proto) ||
       proto->isComputingRequirementSignature())
-    return ErrorType::get(ctx);
+    return CheckTypeWitnessResult::forError();
 
   // No move-only type can witness an associatedtype requirement.
   if (type->isPureMoveOnly()) {
     // describe the failure reason as it not conforming to Copyable
     auto *copyable = ctx.getProtocol(KnownProtocolKind::Copyable);
     assert(copyable && "missing _Copyable protocol!");
-    return CheckTypeWitnessResult(copyable->getDeclaredInterfaceType());
+    return CheckTypeWitnessResult::forConformance(copyable);
   }
 
   const auto depTy = DependentMemberType::get(proto->getSelfInterfaceType(),
@@ -4656,7 +4656,7 @@ swift::checkTypeWitness(Type type, AssociatedTypeDecl *assocType,
         superclass = dc->mapTypeIntoContext(superclass);
     }
     if (!superclass->isExactSuperclassOf(contextType))
-      return superclass;
+      return CheckTypeWitnessResult::forSuperclass(superclass);
   }
 
   auto *module = dc->getParentModule();
@@ -4668,7 +4668,7 @@ swift::checkTypeWitness(Type type, AssociatedTypeDecl *assocType,
             /*allowMissing=*/reqProto->isSpecificProtocol(
                 KnownProtocolKind::Sendable))
             .isInvalid())
-      return CheckTypeWitnessResult(reqProto->getDeclaredInterfaceType());
+      return CheckTypeWitnessResult::forConformance(reqProto);
 
     // FIXME: Why is conformsToProtocol() not enough? The stdlib doesn't
     // build unless we fail here while inferring an associated type
@@ -4681,17 +4681,17 @@ swift::checkTypeWitness(Type type, AssociatedTypeDecl *assocType,
           decl->getGenericEnvironmentOfContext());
       for (auto replacement : subMap.getReplacementTypes()) {
         if (replacement->hasError())
-          return CheckTypeWitnessResult(reqProto->getDeclaredInterfaceType());
+          return CheckTypeWitnessResult::forConformance(reqProto);
       }
     }
   }
 
   if (sig->requiresClass(depTy) &&
       !contextType->satisfiesClassConstraint())
-    return CheckTypeWitnessResult(module->getASTContext().getAnyObjectType());
+    return CheckTypeWitnessResult::forLayout(module->getASTContext().getAnyObjectType());
 
   // Success!
-  return CheckTypeWitnessResult();
+  return CheckTypeWitnessResult::forSuccess();
 }
 
 ResolveWitnessResult
@@ -4878,15 +4878,15 @@ ResolveWitnessResult ConformanceChecker::resolveTypeWitnessViaLookup(
       auto &diags = conformance->getDeclContext()->getASTContext().Diags;
       for (auto candidate : nonViable) {
         if (candidate.first->getDeclaredInterfaceType()->hasError() ||
-            candidate.second.isError())
+            candidate.second.getKind() == CheckTypeWitnessResult::Error)
           continue;
 
         diags.diagnose(
            candidate.first,
            diag::protocol_witness_nonconform_type,
            candidate.first->getDeclaredInterfaceType(),
            candidate.second.getRequirement(),
-           candidate.second.isConformanceRequirement());
+           candidate.second.getKind() != CheckTypeWitnessResult::Superclass);
       }
     });
 

lib/Sema/TypeCheckProtocol.h

@@ -72,23 +72,61 @@ struct TypeWitnessConflict {
 ///
 /// This class evaluates true if an error occurred.
 class CheckTypeWitnessResult {
-  Type Requirement;
+public:
+  enum Kind {
+    Success,
+
+    /// Type witness contains an error type.
+    Error,
+
+    /// Type witness does not satisfy a conformance requirement on
+    /// the associated type.
+    Conformance,
+
+    /// Type witness does not satisfy a superclass requirement on
+    /// the associated type.
+    Superclass,
+
+    /// Type witness does not satisfy a layout requirement on
+    /// the associated type.
+    Layout
+  } kind;
+
+private:
+  Type reqt;
+
+  CheckTypeWitnessResult() : kind(Success) {}
+
+  CheckTypeWitnessResult(Kind kind, Type reqt)
+    : kind(kind), reqt(reqt) {}
 
 public:
-  CheckTypeWitnessResult() { }
-  CheckTypeWitnessResult(Type reqt) : Requirement(reqt) {}
+  static CheckTypeWitnessResult forSuccess() {
+    return CheckTypeWitnessResult(Success, Type());
+  }
 
-  Type getRequirement() const { return Requirement; }
-  bool isConformanceRequirement() const {
-    return Requirement->isExistentialType();
+  static CheckTypeWitnessResult forError() {
+    return CheckTypeWitnessResult(Error, Type());
   }
-  bool isSuperclassRequirement() const {
-    return !isConformanceRequirement();
+
+  static CheckTypeWitnessResult forConformance(ProtocolDecl *proto) {
+    auto reqt = proto->getDeclaredInterfaceType();
+    return CheckTypeWitnessResult(Conformance, reqt);
   }
-  bool isError() const {
-    return Requirement->is<ErrorType>();
+
+  static CheckTypeWitnessResult forSuperclass(Type reqt) {
+    assert(reqt->getClassOrBoundGenericClass());
+    return CheckTypeWitnessResult(Superclass, reqt);
   }
-  explicit operator bool() const { return !Requirement.isNull(); }
+
+  static CheckTypeWitnessResult forLayout(Type reqt) {
+    return CheckTypeWitnessResult(Layout, reqt);
+  }
+
+  Kind getKind() const { return kind; }
+  Type getRequirement() const { return reqt; }
+
+  explicit operator bool() const { return kind != Success; }
 };
 
 /// Check whether the given type witness can be used for the given
@@ -1057,7 +1095,7 @@ class AssociatedTypeInference {
   /// Information about a failed, defaulted associated type.
   const AssociatedTypeDecl *failedDefaultedAssocType = nullptr;
   Type failedDefaultedWitness;
-  CheckTypeWitnessResult failedDefaultedResult;
+  CheckTypeWitnessResult failedDefaultedResult = CheckTypeWitnessResult::forSuccess();
 
   /// Information about a failed, derived associated type.
   AssociatedTypeDecl *failedDerivedAssocType = nullptr;

lib/Sema/TypeCheckProtocolInference.cpp

@@ -1407,10 +1407,10 @@ AssociatedTypeDecl *AssociatedTypeInference::inferAbstractTypeWitnesses(
       // witness failure and we haven't seen one already, write it down.
       auto *defaultedAssocType = witness.getDefaultedAssocType();
       if (defaultedAssocType && !failedDefaultedAssocType &&
-          !failed.isError()) {
+          failed.getKind() != CheckTypeWitnessResult::Error) {
         failedDefaultedAssocType = defaultedAssocType;
         failedDefaultedWitness = type;
-        failedDefaultedResult = std::move(failed);
+        failedDefaultedResult = failed;
       }
 
       return assocType;
@@ -1942,7 +1942,7 @@ bool AssociatedTypeInference::diagnoseNoSolutions(
                        failedDefaultedAssocType,
                        proto->getDeclaredInterfaceType(),
                        failedDefaultedResult.getRequirement(),
-                       failedDefaultedResult.isConformanceRequirement());
+                       failedDefaultedResult.getKind() != CheckTypeWitnessResult::Superclass);
       });
 
     return true;
@@ -1977,12 +1977,12 @@ bool AssociatedTypeInference::diagnoseNoSolutions(
         diags.diagnose(assocType, diag::bad_associated_type_deduction,
                        assocType, proto);
         for (const auto &failed : failedSet) {
-          if (failed.Result.isError())
+          if (failed.Result.getKind() == CheckTypeWitnessResult::Error)
             continue;
 
           if ((!failed.TypeWitness->getAnyNominal() ||
                failed.TypeWitness->isExistentialType()) &&
-              failed.Result.isConformanceRequirement()) {
+              failed.Result.getKind() != CheckTypeWitnessResult::Superclass) {
             Type resultType;
             SourceRange typeRange;
             if (auto *var = dyn_cast<VarDecl>(failed.Witness)) {
@@ -2018,7 +2018,7 @@ bool AssociatedTypeInference::diagnoseNoSolutions(
             continue;
           }
           if (!failed.TypeWitness->getClassOrBoundGenericClass() &&
-              failed.Result.isSuperclassRequirement()) {
+              failed.Result.getKind() == CheckTypeWitnessResult::Superclass) {
             diags.diagnose(failed.Witness,
                            diag::associated_type_witness_inherit_impossible,
                            assocType, failed.TypeWitness,
@@ -2030,7 +2030,7 @@ bool AssociatedTypeInference::diagnoseNoSolutions(
                          diag::associated_type_deduction_witness_failed,
                          assocType, failed.TypeWitness,
                          failed.Result.getRequirement(),
-                         failed.Result.isConformanceRequirement());
+                         failed.Result.getKind() != CheckTypeWitnessResult::Superclass);
         }
       });