Upgrade Core to 428cbdf92f6330b0f6ae918ac0a9dce089a0470b (#883)

Signed-off-by: Juan Cruz Viotti <jv@jviotti.com>

Author: jviotti

DEPENDENCIES

@@ -1,5 +1,5 @@
 vendorpull https://github.com/sourcemeta/vendorpull 1dcbac42809cf87cb5b045106b863e17ad84ba02
-core https://github.com/sourcemeta/core bb1c78e8fa148a2ece951bb776798a43fe328821
+core https://github.com/sourcemeta/core 428cbdf92f6330b0f6ae918ac0a9dce089a0470b
 jsonschema-test-suite https://github.com/json-schema-org/JSON-Schema-Test-Suite 60755c1097769e313fae3ec4d63bcc9d49b5d2d5
 jsonschema-2020-12 https://github.com/json-schema-org/json-schema-spec 769daad75a9553562333a8937a187741cb708c72
 jsonschema-2019-09 https://github.com/json-schema-org/json-schema-spec 41014ea723120ce70b314d72f863c6929d9f3cfd

src/alterschema/canonicalizer/dependencies_to_any_of.h

@@ -22,8 +22,8 @@ class DependenciesToAnyOf final : public SchemaTransformRule {
     const auto *dependencies{schema.try_at("dependencies")};
     ONLY_CONTINUE_IF(dependencies && dependencies->is_object());
 
-    ONLY_CONTINUE_IF(
-        std::ranges::any_of(dependencies->as_object(), [](const auto &entry) {
+    ONLY_CONTINUE_IF(std::ranges::any_of(
+        dependencies->as_object(), [](const auto &entry) -> auto {
           return is_schema(entry.second) || entry.second.is_array();
         }));
     return true;

src/alterschema/canonicalizer/dependencies_to_extends_disallow.h

@@ -21,8 +21,8 @@ class DependenciesToExtendsDisallow final : public SchemaTransformRule {
     const auto *dependencies{schema.try_at("dependencies")};
     ONLY_CONTINUE_IF(dependencies && dependencies->is_object());
 
-    ONLY_CONTINUE_IF(
-        std::ranges::any_of(dependencies->as_object(), [](const auto &entry) {
+    ONLY_CONTINUE_IF(std::ranges::any_of(
+        dependencies->as_object(), [](const auto &entry) -> auto {
           return is_schema(entry.second) || entry.second.is_array() ||
                  entry.second.is_string();
         }));

src/alterschema/canonicalizer/dependent_required_to_any_of.h

@@ -26,7 +26,7 @@ class DependentRequiredToAnyOf final : public SchemaTransformRule {
 
     ONLY_CONTINUE_IF(std::ranges::any_of(
         dependent_required->as_object(),
-        [](const auto &entry) { return entry.second.is_array(); }));
+        [](const auto &entry) -> auto { return entry.second.is_array(); }));
 
     if (!vocabularies.contains_any(
             {Vocabularies::Known::JSON_Schema_2019_09_Applicator,

src/alterschema/canonicalizer/implicit_contains_keywords.h

@@ -28,16 +28,17 @@ class ImplicitContainsKeywords final : public SchemaTransformRule {
     } else {
       ONLY_CONTINUE_IF(!schema.defines("minContains") &&
                        !schema.defines("maxContains"));
-      ONLY_CONTINUE_IF(!WALK_UP_IN_PLACE_APPLICATORS(
-                            root, frame, location, walker, resolver,
-                            [](const JSON &ancestor,
-                               const Vocabularies &ancestor_vocabularies) {
-                              return ancestor.defines("unevaluatedItems") &&
-                                     ancestor_vocabularies.contains(
-                                         Vocabularies::Known::
-                                             JSON_Schema_2020_12_Unevaluated);
-                            })
-                            .has_value());
+      ONLY_CONTINUE_IF(
+          !WALK_UP_IN_PLACE_APPLICATORS(
+               root, frame, location, walker, resolver,
+               [](const JSON &ancestor,
+                  const Vocabularies &ancestor_vocabularies) -> bool {
+                 return ancestor.defines("unevaluatedItems") &&
+                        ancestor_vocabularies.contains(
+                            Vocabularies::Known::
+                                JSON_Schema_2020_12_Unevaluated);
+               })
+               .has_value());
     }
 
     return true;

src/alterschema/canonicalizer/items_implicit.h

@@ -41,7 +41,7 @@ class ItemsImplicit final : public SchemaTransformRule {
         !WALK_UP_IN_PLACE_APPLICATORS(
              root, frame, location, walker, resolver,
              [](const JSON &ancestor,
-                const Vocabularies &ancestor_vocabularies) {
+                const Vocabularies &ancestor_vocabularies) -> bool {
                return ancestor.defines("unevaluatedItems") &&
                       ancestor_vocabularies.contains_any(
                           {Vocabularies::Known::JSON_Schema_2020_12_Unevaluated,

src/alterschema/canonicalizer/type_inherit_in_place.h

@@ -51,11 +51,11 @@ class TypeInheritInPlace final : public SchemaTransformRule {
     // rules may want to lift type out of conjunctions
     const auto ancestor{WALK_UP(
         root, frame, location, walker, resolver,
-        [](const SchemaKeywordType keyword_type) {
+        [](const SchemaKeywordType keyword_type) -> bool {
           return IS_IN_PLACE_APPLICATOR(keyword_type) &&
                  keyword_type != SchemaKeywordType::ApplicatorElementsInPlace;
         },
-        [](const JSON &ancestor_schema, const Vocabularies &) {
+        [](const JSON &ancestor_schema, const Vocabularies &) -> bool {
           return ancestor_schema.defines("type");
         })};
 

src/alterschema/canonicalizer/unsatisfiable_type_and_enum.h

@@ -44,7 +44,7 @@ class UnsatisfiableTypeAndEnum final : public SchemaTransformRule {
         declared_types.test(std::to_underlying(JSON::Type::Integer))};
     ONLY_CONTINUE_IF(std::ranges::none_of(
         enum_value->as_array(),
-        [&declared_types, integer_matches_integral](const auto &value) {
+        [&declared_types, integer_matches_integral](const auto &value) -> auto {
           return declared_types.test(std::to_underlying(value.type())) ||
                  (integer_matches_integral && value.is_integral());
         }));

src/alterschema/common/content_schema_without_media_type.h

@@ -1,5 +1,6 @@
 class ContentSchemaWithoutMediaType final : public SchemaTransformRule {
 private:
+  // NOLINTNEXTLINE(bugprone-throwing-static-initialization)
   static inline const std::string KEYWORD{"contentSchema"};
 
 public:

src/alterschema/common/dependencies_property_tautology.h

@@ -38,7 +38,7 @@ class DependenciesPropertyTautology final : public SchemaTransformRule {
       ONLY_CONTINUE_IF(properties && properties->is_object());
 
       ONLY_CONTINUE_IF(std::ranges::any_of(
-          properties->as_object(), [dependencies](const auto &entry) {
+          properties->as_object(), [dependencies](const auto &entry) -> auto {
             if (!entry.second.is_object()) {
               return false;
             }
@@ -58,7 +58,7 @@ class DependenciesPropertyTautology final : public SchemaTransformRule {
     ONLY_CONTINUE_IF(required && required->is_array());
 
     ONLY_CONTINUE_IF(std::ranges::any_of(
-        required->as_array(), [dependencies](const auto &element) {
+        required->as_array(), [dependencies](const auto &element) -> auto {
           if (!element.is_string()) {
             return false;
           }
@@ -70,7 +70,7 @@ class DependenciesPropertyTautology final : public SchemaTransformRule {
 
   auto transform(JSON &schema, const Result &result) const -> void override {
     const bool is_draft_3_path{
-        std::ranges::any_of(result.locations, [](const auto &pointer) {
+        std::ranges::any_of(result.locations, [](const auto &pointer) -> auto {
           return pointer.size() == 1 && pointer.at(0).is_property() &&
                  pointer.at(0).to_property() == "properties";
         })};