VS Code: display custom warnings in the Problems tab

How do you display custom issues in the Problems view during build?

Visual Studio Code offers a Problems tab that displays errors and warnings from your code. While it works well with built-in linters and compilers, sometimes you need to integrate custom validation tools into your workflow.

In this post, I’ll show you how to create a custom program that emits warnings and errors that VS Code can recognize and display in the Problems tab.

The solution (using the problemMatcher feature of VS Code tasks)

I’ve created a minimal example project that demonstrates how to:

1. Create a simple program that emits warnings in a specific format
2. Configure VS Code to recognize these warnings
3. Integrate this into your build process to block builds when issues are found

A complete example of how to capture custom warning messages during the build is available in my GitHub repository.

Step 1: Create a Custom Validation Program

First, we need a program to check whatever custom conditions you need and output warnings in a format VS Code can understand. Here’s a minimal C# example:

namespace ScanForSeoIssues;

internal class Program
{
  static int Main(string[] args)
  {
    // emit some fake warnings for demo purposes
    var filePath = "D:\\Projekty\\FlashcardSpace.Blog\\flashcard-space\\.vscode\\tasks.json";

    Console.WriteLine($"warning: file '{filePath}', line '15', column '17': custom warning message");
    Console.WriteLine($"error: file '{filePath}', line '16', column '18': custom error message");

    // return non-zero error code to signal that check failed and stop the build
    return 1;
  }
}
Code language: C# (cs)

Step 2: Configure VS Code Tasks

Now, we need to set up VS Code to run our validator and parse its output. Here’s example tasks.json configuration:

{
  "version": "2.0.0",
  "tasks": [
    // Define pre-build task to detect issues with custom C# program, and emit warnings/errors if found
    {
      "label": "custom scan for quality issues",

      "type": "shell",
      "command": "dotnet run --project ./scripts/ScanForSeoIssues/ScanForSeoIssues.csproj",

      // Problem matcher instructs VS Code how to capture the errors and warnings from the program output
      "problemMatcher": [
        {
          // Unique id to help VS code clear warnings from the Problems window when you re-run the task
          "owner": "custom-seo-warning",

          // Format of the file path in error message might be auto-detected but being explicit is more reliable
          "fileLocation": "absolute",

          "pattern": {
            // This regex needs to be adjusted to how your custom tool outputs errors and warnings to the console output
            "regexp": "^(warning|error): file '([^']+)', line '(\\d+)', column '(\\d+)': (.+)$",

            // The numbers below are 1-based indexes of the regex groups
            "severity": 1,
            "file": 2,
            "line": 3,
            "column": 4,
            "message": 5
          }
        }
      ],

      "presentation": {
        // Switch to the Problems view from the Terminal view in case of detected warnings or errors
        "revealProblems": "onProblem",

        // Clear the terminal output when the task is re-run for readability
        "clear": true
      }
    },

    // Example build task  (typically started with F6 key)
    {
      "label": "Build website",
      "type": "shell",
      "command": "echo 'Building the project... (this should never be displayed in this demo because of the detected custom errors)'",
      "group": {
        "kind": "build",
        "isDefault": true
      },

      // Key line: this task depends on the custom scan task above, and requires it to succeed before running
      "dependsOn": ["custom scan for quality issues"]
    }
  ]
}

Code language: JSON / JSON with Comments (json)

That’s basically it. You can adjust the regex to the format of your warnings and fine-tune other parameters if you like.

Conclusion

This approach allows you to integrate custom validation into your VS Code workflow.

The best part is that your custom tool can be written in any language. Just align its output with the format your problem matcher expects and return the appropriate exit code.

Good luck!