fix: wildcard patterns with 0 matches are OK; literal patterns with 0 matches emit SLNX020

Agent-Logs-Url: https://github.com/304NotModified/SLNX-validator/sessions/deabf102-3e90-4a06-a252-62362daaa419

Co-authored-by: 304NotModified <5808377+304NotModified@users.noreply.github.com>

Author: Copilot

README.md

@@ -104,7 +104,8 @@ Always exits with code `0`, even when validation errors are found. Useful in CI
 
 Verify that a set of files or directories matching glob patterns exist on disk **and** are referenced as `<File>` entries in the solution file(s) being validated. Any failure is reported as a normal validation error (exit code `1`) that also appears in SonarQube reports.
 
-- **Reference check** — for each matched file that is not referenced as `<File Path="...">` in the `.slnx`, a `SLNX021` (`RequiredFileNotReferencedInSolution`) error is added. The error message shows the exact `<File>` element that should be added. If the pattern matches no files, the check is skipped silently (not an error).
+- **Disk check** — if a **literal** (non-wildcard) pattern matches no files on disk, a `SLNX020` (`RequiredFileDoesntExistOnSystem`) error is added. If the pattern contains wildcards (`*` or `?`) and matches no files, the check is skipped silently — zero matches is not an error.
+- **Reference check** — for each matched file that is not referenced as `<File Path="...">` in the `.slnx`, a `SLNX021` (`RequiredFileNotReferencedInSolution`) error is added. The error message shows the exact `<File>` element that should be added.
 
 Relative paths in the `.slnx` are resolved relative to the solution file's location.
 
@@ -149,8 +150,8 @@ slnx-validator MySolution.slnx --required-files "appsettings.json;docs/"
 
 | Code | Description |
 |------|-------------|
-| `0`  | All matched files are referenced in the solution (or no files matched the pattern). |
-| `1`  | Any validation error — including required files not referenced. |
+| `0`  | All matched files are referenced in the solution (or a wildcard pattern matched no files). |
+| `1`  | Any validation error — including a literal required file not existing or matched files not referenced. |
 
 ### Severity override flags
 
@@ -402,6 +403,7 @@ The following are **intentionally out of scope** because the toolchain already h
 | `SLNX011` | `ReferencedFileNotFound`  | A file referenced in `<File Path="...">` does not exist on disk. |
 | `SLNX012` | `InvalidWildcardUsage`    | A `<File Path="...">` contains a wildcard pattern (see [`examples/invalid-wildcard.slnx`](examples/invalid-wildcard.slnx)). |
 | `SLNX013` | `XsdViolation`            | The XML structure violates the schema, e.g. `<Folder>` inside `<Folder>` (see [`examples/invalid-xsd.slnx`](examples/invalid-xsd.slnx)). |
+| `SLNX020` | `RequiredFileDoesntExistOnSystem`   | A literal (non-wildcard) `--required-files` pattern matched no files on the file system. |
 | `SLNX021` | `RequiredFileNotReferencedInSolution` | A `--required-files` matched file exists on disk but is not referenced as a `<File>` element in the solution. |
 
 ## XSD Schema

src/SLNX-validator/RequiredFilesOptions.cs

@@ -6,10 +6,18 @@ namespace JulianVerdurmen.SlnxValidator;
 /// </summary>
 /// <param name="MatchedPaths">
 /// Absolute disk paths that were matched by <see cref="Pattern"/>.
-/// An empty list means the pattern matched no files — this is not an error (no files to check).
+/// An empty list with a wildcard pattern means no files to check — not an error.
+/// An empty list with a literal (non-wildcard) pattern means the file does not exist — emits <c>SLNX020</c>.
 /// <see langword="null"/> means the <c>--required-files</c> option was not used.
 /// </param>
 /// <param name="Pattern">The raw semicolon-separated pattern string supplied by the user.</param>
 internal sealed record RequiredFilesOptions(
     IReadOnlyList<string>? MatchedPaths,
-    string? Pattern);
+    string? Pattern)
+{
+    /// <summary>
+    /// Returns <see langword="true"/> when <see cref="Pattern"/> contains wildcard characters
+    /// (<c>*</c> or <c>?</c>), meaning zero matches is not an error.
+    /// </summary>
+    internal bool HasWildcard => Pattern is not null && (Pattern.Contains('*') || Pattern.Contains('?'));
+}

src/SLNX-validator/SlnxCollector.cs

@@ -61,7 +61,16 @@ public async Task<IReadOnlyList<FileValidationResult>> CollectAsync(
             if (requiredFilesOptions is not null)
             {
                 var matched = requiredFilesOptions.MatchedPaths;
-                if (matched is not null && matched.Count > 0)
+                if (matched is null || matched.Count == 0)
+                {
+                    if (!requiredFilesOptions.HasWildcard)
+                    {
+                        allErrors.Add(new ValidationError(
+                            ValidationErrorCode.RequiredFileDoesntExistOnSystem,
+                            $"Required file does not exist on the system. No files matched: {requiredFilesOptions.Pattern}"));
+                    }
+                }
+                else
                 {
                     var hasXsdErrors = allErrors.Any(e => e.Code == ValidationErrorCode.XsdViolation);
                     if (!hasXsdErrors)

tests/SLNX-validator.Tests/SlnxCollectorTests.cs

@@ -31,7 +31,7 @@ private static (SlnxCollector collector, IRequiredFilesChecker checker) CreateCo
     #region CollectAsync
 
     [Test]
-    public async Task CollectAsync_RequiredFilesPatternNoMatch_NoError()
+    public async Task CollectAsync_WildcardPatternNoMatch_NoError()
     {
         // Arrange
         var (collector, _) = CreateCollector();
@@ -45,6 +45,22 @@ public async Task CollectAsync_RequiredFilesPatternNoMatch_NoError()
         results[0].HasErrors.Should().BeFalse();
     }
 
+    [Test]
+    public async Task CollectAsync_LiteralPatternNoMatch_AddsRequiredFileDoesntExistOnSystemError()
+    {
+        // Arrange
+        var (collector, _) = CreateCollector();
+        var options = new RequiredFilesOptions(MatchedPaths: [], Pattern: "unknownfile.md");
+
+        // Act
+        var results = await collector.CollectAsync(SlnxPath, options, CancellationToken.None);
+
+        // Assert
+        results.Should().HaveCount(1);
+        results[0].HasErrors.Should().BeTrue();
+        results[0].Errors.Should().ContainSingle(e => e.Code == ValidationErrorCode.RequiredFileDoesntExistOnSystem);
+    }
+
     [Test]
     public async Task CollectAsync_RequiredFileMissingFromSlnx_AddsRequiredFileNotReferencedInSolutionError()
     {

tests/SLNX-validator.Tests/ValidatorRunnerTests.cs

@@ -125,14 +125,14 @@ public async Task RunAsync_RequiredFiles_AllMatchedAndReferenced_ReturnsZero()
     }
 
     [Test]
-    public async Task RunAsync_RequiredFiles_NoMatchOnDisk_ReturnsZero()
+    public async Task RunAsync_RequiredFiles_WildcardNoMatchOnDisk_ReturnsZero()
     {
         // Arrange
         var slnxPath = Path.GetFullPath("test.slnx");
 
         var checker = Substitute.For<IRequiredFilesChecker>();
         checker.ResolveMatchedPaths(Arg.Any<string>(), Arg.Any<string>())
-            .Returns([]); // nothing matched on disk — no error expected
+            .Returns([]); // nothing matched on disk — wildcard, so no error expected
 
         var runner = CreateRunnerWithSlnx(slnxPath, "<Solution />", checker);
 
@@ -144,6 +144,26 @@ public async Task RunAsync_RequiredFiles_NoMatchOnDisk_ReturnsZero()
         exitCode.Should().Be(0);
     }
 
+    [Test]
+    public async Task RunAsync_RequiredFiles_LiteralNoMatchOnDisk_ReturnsOne()
+    {
+        // Arrange
+        var slnxPath = Path.GetFullPath("test.slnx");
+
+        var checker = Substitute.For<IRequiredFilesChecker>();
+        checker.ResolveMatchedPaths(Arg.Any<string>(), Arg.Any<string>())
+            .Returns([]); // nothing matched on disk — literal path, so SLNX020 expected
+
+        var runner = CreateRunnerWithSlnx(slnxPath, "<Solution />", checker);
+
+        // Act
+        var exitCode = await runner.RunAsync(
+            Options(slnxPath, requiredFilesPattern: "unknownfile.md"), CancellationToken.None);
+
+        // Assert
+        exitCode.Should().Be(1);
+    }
+
     #endregion
 
     #region RunAsync – severity overrides