Runtime: Extract checkGenericRequirement() from checkGenericRequirements()

Author: slavapestov

stdlib/public/runtime/ProtocolConformance.cpp

@@ -1281,122 +1281,135 @@ bool swift::_swift_class_isSubclass(const Metadata *subclass,
   return isSubclass(subclass, superclass);
 }
 
-llvm::Optional<TypeLookupError> swift::_checkGenericRequirements(
-    llvm::ArrayRef<GenericRequirementDescriptor> requirements,
-    llvm::SmallVectorImpl<const void *> &extraArguments,
-    SubstGenericParameterFn substGenericParam,
-    SubstDependentWitnessTableFn substWitnessTable) {
-  for (const auto &req : requirements) {
-    // Make sure we understand the requirement we're dealing with.
-    if (!req.hasKnownKind())
-      return TypeLookupError("unknown kind");
+static llvm::Optional<TypeLookupError>
+checkGenericRequirement(const GenericRequirementDescriptor &req,
+                        llvm::SmallVectorImpl<const void *> &extraArguments,
+                        SubstGenericParameterFn substGenericParam,
+                        SubstDependentWitnessTableFn substWitnessTable) {
+  assert(!req.getFlags().isPackRequirement());
+
+  // Make sure we understand the requirement we're dealing with.
+  if (!req.hasKnownKind())
+    return TypeLookupError("unknown kind");
+
+  // Resolve the subject generic parameter.
+  auto result = swift_getTypeByMangledName(
+      MetadataState::Abstract, req.getParam(), extraArguments.data(),
+      substGenericParam, substWitnessTable);
+  if (result.getError())
+    return *result.getError();
+  const Metadata *subjectType = result.getType().getMetadata();
+
+  // Check the requirement.
+  switch (req.getKind()) {
+  case GenericRequirementKind::Protocol: {
+    const WitnessTable *witnessTable = nullptr;
+    if (!_conformsToProtocol(nullptr, subjectType, req.getProtocol(),
+                             &witnessTable)) {
+      const char *protoName =
+          req.getProtocol() ? req.getProtocol().getName() : "<null>";
+      return TYPE_LOOKUP_ERROR_FMT(
+          "subject type %.*s does not conform to protocol %s",
+          (int)req.getParam().size(), req.getParam().data(), protoName);
+    }
 
-    if (req.getFlags().isPackRequirement())
-      return TypeLookupError("Packs not supported here yet");
+    // If we need a witness table, add it.
+    if (req.getProtocol().needsWitnessTable()) {
+      assert(witnessTable);
+      extraArguments.push_back(witnessTable);
+    }
 
-    // Resolve the subject generic parameter.
+    return llvm::None;
+  }
+
+  case GenericRequirementKind::SameType: {
+    // Demangle the second type under the given substitutions.
     auto result = swift_getTypeByMangledName(
-        MetadataState::Abstract, req.getParam(), extraArguments.data(),
-        substGenericParam, substWitnessTable);
+        MetadataState::Abstract, req.getMangledTypeName(),
+        extraArguments.data(), substGenericParam, substWitnessTable);
     if (result.getError())
       return *result.getError();
-    const Metadata *subjectType = result.getType().getMetadata();
-
-    // Check the requirement.
-    switch (req.getKind()) {
-    case GenericRequirementKind::Protocol: {
-      const WitnessTable *witnessTable = nullptr;
-      if (!_conformsToProtocol(nullptr, subjectType, req.getProtocol(),
-                               &witnessTable)) {
-        const char *protoName =
-            req.getProtocol() ? req.getProtocol().getName() : "<null>";
-        return TYPE_LOOKUP_ERROR_FMT(
-            "subject type %.*s does not conform to protocol %s",
-            (int)req.getParam().size(), req.getParam().data(), protoName);
-      }
-
-      // If we need a witness table, add it.
-      if (req.getProtocol().needsWitnessTable()) {
-        assert(witnessTable);
-        extraArguments.push_back(witnessTable);
-      }
-
-      continue;
+    auto otherType = result.getType().getMetadata();
+
+    // Check that the types are equivalent.
+    if (subjectType != otherType) {
+      return TYPE_LOOKUP_ERROR_FMT(
+          "subject type %.*s does not match %.*s", (int)req.getParam().size(),
+          req.getParam().data(), (int)req.getMangledTypeName().size(),
+          req.getMangledTypeName().data());
     }
 
-    case GenericRequirementKind::SameType: {
-      // Demangle the second type under the given substitutions.
-      auto result = swift_getTypeByMangledName(
-          MetadataState::Abstract, req.getMangledTypeName(),
-          extraArguments.data(), substGenericParam, substWitnessTable);
-      if (result.getError())
-        return *result.getError();
-      auto otherType = result.getType().getMetadata();
-
-      // Check that the types are equivalent.
-      if (subjectType != otherType)
-        return TYPE_LOOKUP_ERROR_FMT(
-            "subject type %.*s does not match %.*s", (int)req.getParam().size(),
-            req.getParam().data(), (int)req.getMangledTypeName().size(),
-            req.getMangledTypeName().data());
+    return llvm::None;
+  }
 
-      continue;
+  case GenericRequirementKind::Layout: {
+    switch (req.getLayout()) {
+    case GenericRequirementLayoutKind::Class:
+      if (!subjectType->satisfiesClassConstraint()) {
+        return TYPE_LOOKUP_ERROR_FMT(
+            "subject type %.*s does not satisfy class constraint",
+            (int)req.getParam().size(), req.getParam().data());
+      }
+      return llvm::None;
     }
 
-    case GenericRequirementKind::Layout: {
-      switch (req.getLayout()) {
-      case GenericRequirementLayoutKind::Class:
-        if (!subjectType->satisfiesClassConstraint())
-          return TYPE_LOOKUP_ERROR_FMT(
-              "subject type %.*s does not satisfy class constraint",
-              (int)req.getParam().size(), req.getParam().data());
-        continue;
-      }
+    // Unknown layout.
+    return TYPE_LOOKUP_ERROR_FMT("unknown layout kind %u", req.getLayout());
+  }
 
-      // Unknown layout.
-      return TYPE_LOOKUP_ERROR_FMT("unknown layout kind %u", req.getLayout());
+  case GenericRequirementKind::BaseClass: {
+    // Demangle the base type under the given substitutions.
+    auto result = swift_getTypeByMangledName(
+        MetadataState::Abstract, req.getMangledTypeName(),
+        extraArguments.data(), substGenericParam, substWitnessTable);
+    if (result.getError())
+      return *result.getError();
+    auto baseType = result.getType().getMetadata();
+
+    // If the type which is constrained to a base class is an existential 
+    // type, and if that existential type includes a superclass constraint,
+    // just require that the superclass by which the existential is
+    // constrained is a subclass of the base class.
+    if (auto *existential = dyn_cast<ExistentialTypeMetadata>(subjectType)) {
+      if (auto *superclassConstraint = existential->getSuperclassConstraint())
+        subjectType = superclassConstraint;
     }
 
-    case GenericRequirementKind::BaseClass: {
-      // Demangle the base type under the given substitutions.
-      auto result = swift_getTypeByMangledName(
-          MetadataState::Abstract, req.getMangledTypeName(),
-          extraArguments.data(), substGenericParam, substWitnessTable);
-      if (result.getError())
-        return *result.getError();
-      auto baseType = result.getType().getMetadata();
-
-      // If the type which is constrained to a base class is an existential 
-      // type, and if that existential type includes a superclass constraint,
-      // just require that the superclass by which the existential is
-      // constrained is a subclass of the base class.
-      if (auto *existential = dyn_cast<ExistentialTypeMetadata>(subjectType)) {
-        if (auto *superclassConstraint = existential->getSuperclassConstraint())
-          subjectType = superclassConstraint;
-      }
+    if (!isSubclass(subjectType, baseType))
+      return TYPE_LOOKUP_ERROR_FMT(
+          "%.*s is not subclass of %.*s", (int)req.getParam().size(),
+          req.getParam().data(), (int)req.getMangledTypeName().size(),
+          req.getMangledTypeName().data());
 
-      if (!isSubclass(subjectType, baseType))
-        return TYPE_LOOKUP_ERROR_FMT(
-            "%.*s is not subclass of %.*s", (int)req.getParam().size(),
-            req.getParam().data(), (int)req.getMangledTypeName().size(),
-            req.getMangledTypeName().data());
+    return llvm::None;
+  }
 
-      continue;
-    }
+  case GenericRequirementKind::SameConformance: {
+    // FIXME: Implement this check.
+    return llvm::None;
+  }
 
-    case GenericRequirementKind::SameConformance: {
-      // FIXME: Implement this check.
-      continue;
-    }
+  case GenericRequirementKind::SameShape: {
+    return TYPE_LOOKUP_ERROR_FMT("can't have same-shape requirement where "
+                                 "subject type is not a pack");
+  }
+  }
 
-    case GenericRequirementKind::SameShape: {
-      llvm_unreachable("Implement me");
-    }
-    }
+  // Unknown generic requirement kind.
+  return TYPE_LOOKUP_ERROR_FMT("unknown generic requirement kind %u",
+                               (unsigned)req.getKind());
+}
 
-    // Unknown generic requirement kind.
-    return TYPE_LOOKUP_ERROR_FMT("unknown generic requirement kind %u",
-                                 (unsigned)req.getKind());
+llvm::Optional<TypeLookupError> swift::_checkGenericRequirements(
+    llvm::ArrayRef<GenericRequirementDescriptor> requirements,
+    llvm::SmallVectorImpl<const void *> &extraArguments,
+    SubstGenericParameterFn substGenericParam,
+    SubstDependentWitnessTableFn substWitnessTable) {
+  for (const auto &req : requirements) {
+    auto error = checkGenericRequirement(req, extraArguments,
+                                         substGenericParam, substWitnessTable);
+    if (error)
+      return error;
   }
 
   // Success!