feat(linter): add const_and_enum_conflict rule

src/extension/alterschema/CMakeLists.txt

@@ -71,6 +71,7 @@ sourcemeta_library(NAMESPACE sourcemeta PROJECT core NAME alterschema
 
     # Linter
     linter/comment_trim.h
+    linter/const_and_enum_conflict.h
     linter/content_schema_default.h
     linter/definitions_to_defs.h
     linter/dependencies_default.h

src/extension/alterschema/alterschema.cc

@@ -99,6 +99,7 @@ inline auto APPLIES_TO_POINTERS(std::vector<Pointer> &&keywords)
 
 // Linter
 #include "linter/comment_trim.h"
+#include "linter/const_and_enum_conflict.h"
 #include "linter/content_schema_default.h"
 #include "linter/definitions_to_defs.h"
 #include "linter/dependencies_default.h"
@@ -207,6 +208,7 @@ auto add(SchemaTransformer &bundle, const AlterSchemaMode mode) -> void {
 
   if (mode == AlterSchemaMode::Linter) {
     bundle.add<EqualNumericBoundsToConst>();
+    bundle.add<ConstAndEnumConflict>();
     bundle.add<ContentSchemaDefault>();
     bundle.add<DependenciesDefault>();
     bundle.add<DependentRequiredDefault>();

src/extension/alterschema/linter/const_and_enum_conflict.h

@@ -0,0 +1,29 @@
+class ConstAndEnumConflict final : public SchemaTransformRule {
+public:
+  using mutates = std::false_type;
+  using reframe_after_transform = std::false_type;
+  ConstAndEnumConflict()
+      : SchemaTransformRule{
+            "const_and_enum_conflict",
+            "The `const` and `enum` keywords are mutually exclusive; "
+            "use one or the other, not both"} {};
+
+  [[nodiscard]] auto
+  condition(const sourcemeta::core::JSON &schema,
+            const sourcemeta::core::JSON &,
+            const sourcemeta::core::Vocabularies &vocabularies,
+            const sourcemeta::core::SchemaFrame &,
+            const sourcemeta::core::SchemaFrame::Location &,
+            const sourcemeta::core::SchemaWalker &,
+            const sourcemeta::core::SchemaResolver &) const
+      -> sourcemeta::core::SchemaTransformRule::Result override {
+    ONLY_CONTINUE_IF(vocabularies.contains_any(
+                         {Vocabularies::Known::JSON_Schema_2020_12_Validation,
+                          Vocabularies::Known::JSON_Schema_2019_09_Validation,
+                          Vocabularies::Known::JSON_Schema_Draft_7,
+                          Vocabularies::Known::JSON_Schema_Draft_6}) &&
+                     schema.is_object() && schema.defines("const") &&
+                     schema.defines("enum"));
+    return APPLIES_TO_KEYWORDS("const", "enum");
+  }
+};

test/alterschema/alterschema_lint_2019_09_test.cc

@@ -4494,3 +4494,77 @@ TEST(AlterSchema_lint_2019_09, empty_object_as_true_1) {
 
   EXPECT_EQ(document, expected);
 }
+
+TEST(AlterSchema_lint_2019_09, const_and_enum_conflict_1) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "title": "Test",
+    "description": "Test description",
+    "examples": [ 1 ],
+    "const": 1,
+    "enum": [ 1, 2, 3 ]
+  })JSON");
+
+  LINT_WITHOUT_FIX(document, result, traces);
+
+  EXPECT_FALSE(result.first);
+  EXPECT_EQ(traces.size(), 1);
+  EXPECT_LINT_TRACE(traces, 0, "", "const_and_enum_conflict",
+                    "The `const` and `enum` keywords are mutually exclusive; "
+                    "use one or the other, not both",
+                    false);
+}
+
+TEST(AlterSchema_lint_2019_09, const_and_enum_conflict_2) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "title": "Test",
+    "description": "Test description",
+    "examples": [ 1 ],
+    "const": "foo"
+  })JSON");
+
+  LINT_WITHOUT_FIX(document, result, traces);
+
+  EXPECT_TRUE(result.first);
+  EXPECT_EQ(traces.size(), 0);
+}
+
+TEST(AlterSchema_lint_2019_09, const_and_enum_conflict_3) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "title": "Test",
+    "description": "Test description",
+    "examples": [ 1 ],
+    "enum": [ 1, 2, 3 ]
+  })JSON");
+
+  LINT_WITHOUT_FIX(document, result, traces);
+
+  EXPECT_TRUE(result.first);
+  EXPECT_EQ(traces.size(), 0);
+}
+
+TEST(AlterSchema_lint_2019_09, const_and_enum_conflict_4) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "title": "Test",
+    "description": "Test description",
+    "examples": [ {} ],
+    "properties": {
+      "foo": {
+        "const": 1,
+        "enum": [ 1, 2, 3 ]
+      }
+    }
+  })JSON");
+
+  LINT_WITHOUT_FIX(document, result, traces);
+
+  EXPECT_FALSE(result.first);
+  EXPECT_EQ(traces.size(), 1);
+  EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "const_and_enum_conflict",
+                    "The `const` and `enum` keywords are mutually exclusive; "
+                    "use one or the other, not both",
+                    false);
+}

test/alterschema/alterschema_lint_2020_12_test.cc

@@ -9664,3 +9664,77 @@ TEST(AlterSchema_lint_2020_12, object_oneof_required_not_required_6) {
       "can be elevated",
       true);
 }
+
+TEST(AlterSchema_lint_2020_12, const_and_enum_conflict_1) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "title": "Test",
+    "description": "Test description",
+    "examples": [ 1 ],
+    "const": 1,
+    "enum": [ 1, 2, 3 ]
+  })JSON");
+
+  LINT_WITHOUT_FIX(document, result, traces);
+
+  EXPECT_FALSE(result.first);
+  EXPECT_EQ(traces.size(), 1);
+  EXPECT_LINT_TRACE(traces, 0, "", "const_and_enum_conflict",
+                    "The `const` and `enum` keywords are mutually exclusive; "
+                    "use one or the other, not both",
+                    false);
+}
+
+TEST(AlterSchema_lint_2020_12, const_and_enum_conflict_2) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "title": "Test",
+    "description": "Test description",
+    "examples": [ 1 ],
+    "const": "foo"
+  })JSON");
+
+  LINT_WITHOUT_FIX(document, result, traces);
+
+  EXPECT_TRUE(result.first);
+  EXPECT_EQ(traces.size(), 0);
+}
+
+TEST(AlterSchema_lint_2020_12, const_and_enum_conflict_3) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "title": "Test",
+    "description": "Test description",
+    "examples": [ 1 ],
+    "enum": [ 1, 2, 3 ]
+  })JSON");
+
+  LINT_WITHOUT_FIX(document, result, traces);
+
+  EXPECT_TRUE(result.first);
+  EXPECT_EQ(traces.size(), 0);
+}
+
+TEST(AlterSchema_lint_2020_12, const_and_enum_conflict_4) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "title": "Test",
+    "description": "Test description",
+    "examples": [ {} ],
+    "properties": {
+      "foo": {
+        "const": 1,
+        "enum": [ 1, 2, 3 ]
+      }
+    }
+  })JSON");
+
+  LINT_WITHOUT_FIX(document, result, traces);
+
+  EXPECT_FALSE(result.first);
+  EXPECT_EQ(traces.size(), 1);
+  EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "const_and_enum_conflict",
+                    "The `const` and `enum` keywords are mutually exclusive; "
+                    "use one or the other, not both",
+                    false);
+}

test/alterschema/alterschema_lint_draft6_test.cc

@@ -2929,3 +2929,77 @@ TEST(AlterSchema_lint_draft6, empty_object_as_true_1) {
 
   EXPECT_EQ(document, expected);
 }
+
+TEST(AlterSchema_lint_draft6, const_and_enum_conflict_1) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "http://json-schema.org/draft-06/schema#",
+    "title": "Test",
+    "description": "Test description",
+    "examples": [ 1 ],
+    "const": 1,
+    "enum": [ 1, 2, 3 ]
+  })JSON");
+
+  LINT_WITHOUT_FIX(document, result, traces);
+
+  EXPECT_FALSE(result.first);
+  EXPECT_EQ(traces.size(), 1);
+  EXPECT_LINT_TRACE(traces, 0, "", "const_and_enum_conflict",
+                    "The `const` and `enum` keywords are mutually exclusive; "
+                    "use one or the other, not both",
+                    false);
+}
+
+TEST(AlterSchema_lint_draft6, const_and_enum_conflict_2) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "http://json-schema.org/draft-06/schema#",
+    "title": "Test",
+    "description": "Test description",
+    "examples": [ 1 ],
+    "const": "foo"
+  })JSON");
+
+  LINT_WITHOUT_FIX(document, result, traces);
+
+  EXPECT_TRUE(result.first);
+  EXPECT_EQ(traces.size(), 0);
+}
+
+TEST(AlterSchema_lint_draft6, const_and_enum_conflict_3) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "http://json-schema.org/draft-06/schema#",
+    "title": "Test",
+    "description": "Test description",
+    "examples": [ 1 ],
+    "enum": [ 1, 2, 3 ]
+  })JSON");
+
+  LINT_WITHOUT_FIX(document, result, traces);
+
+  EXPECT_TRUE(result.first);
+  EXPECT_EQ(traces.size(), 0);
+}
+
+TEST(AlterSchema_lint_draft6, const_and_enum_conflict_4) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "http://json-schema.org/draft-06/schema#",
+    "title": "Test",
+    "description": "Test description",
+    "examples": [ {} ],
+    "properties": {
+      "foo": {
+        "const": 1,
+        "enum": [ 1, 2, 3 ]
+      }
+    }
+  })JSON");
+
+  LINT_WITHOUT_FIX(document, result, traces);
+
+  EXPECT_FALSE(result.first);
+  EXPECT_EQ(traces.size(), 1);
+  EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "const_and_enum_conflict",
+                    "The `const` and `enum` keywords are mutually exclusive; "
+                    "use one or the other, not both",
+                    false);
+}

test/alterschema/alterschema_lint_draft7_test.cc

@@ -3507,3 +3507,77 @@ TEST(AlterSchema_lint_draft7,
       "illustrate the expected data",
       false);
 }
+
+TEST(AlterSchema_lint_draft7, const_and_enum_conflict_1) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "Test",
+    "description": "Test description",
+    "examples": [ 1 ],
+    "const": 1,
+    "enum": [ 1, 2, 3 ]
+  })JSON");
+
+  LINT_WITHOUT_FIX(document, result, traces);
+
+  EXPECT_FALSE(result.first);
+  EXPECT_EQ(traces.size(), 1);
+  EXPECT_LINT_TRACE(traces, 0, "", "const_and_enum_conflict",
+                    "The `const` and `enum` keywords are mutually exclusive; "
+                    "use one or the other, not both",
+                    false);
+}
+
+TEST(AlterSchema_lint_draft7, const_and_enum_conflict_2) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "Test",
+    "description": "Test description",
+    "examples": [ 1 ],
+    "const": "foo"
+  })JSON");
+
+  LINT_WITHOUT_FIX(document, result, traces);
+
+  EXPECT_TRUE(result.first);
+  EXPECT_EQ(traces.size(), 0);
+}
+
+TEST(AlterSchema_lint_draft7, const_and_enum_conflict_3) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "Test",
+    "description": "Test description",
+    "examples": [ 1 ],
+    "enum": [ 1, 2, 3 ]
+  })JSON");
+
+  LINT_WITHOUT_FIX(document, result, traces);
+
+  EXPECT_TRUE(result.first);
+  EXPECT_EQ(traces.size(), 0);
+}
+
+TEST(AlterSchema_lint_draft7, const_and_enum_conflict_4) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "Test",
+    "description": "Test description",
+    "examples": [ {} ],
+    "properties": {
+      "foo": {
+        "const": 1,
+        "enum": [ 1, 2, 3 ]
+      }
+    }
+  })JSON");
+
+  LINT_WITHOUT_FIX(document, result, traces);
+
+  EXPECT_FALSE(result.first);
+  EXPECT_EQ(traces.size(), 1);
+  EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "const_and_enum_conflict",
+                    "The `const` and `enum` keywords are mutually exclusive; "
+                    "use one or the other, not both",
+                    false);
+}