Add brace matching and fix property-argument highlighting for complex scenarios

- Add new brace matching provider for Serilog templates with multi-line support.
- Fix property-argument highlighting when LogError has Exception as first parameter
- Exclude string literals from parenthesis counting in multi-line detection
- Find template string by properties instead of assuming first string literal
- Add test coverage for both features

Author: willibrandon

CLAUDE.md

@@ -23,6 +23,7 @@ The extension follows a modular architecture designed for performance and mainta
 2. **Providers** (`src/providers/`) ✅
    - `navigationProvider.ts` - Code actions for navigating from properties to arguments
    - `propertyArgumentHighlighter.ts` - Highlights template properties and their corresponding arguments
+   - `braceMatchProvider.ts` - Highlights matching braces in Serilog contexts
 
 3. **Decorations** (`src/decorations/`) ✅
    - `decorationManager.ts` - Manages text decorations for highlighting (replaces semantic tokens)
@@ -90,6 +91,7 @@ vsce publish
 - **Configuration**: Extensive user customization options
 - **Property-Argument Highlighting**: Cursor-based highlighting showing connection between properties and arguments
 - **Navigation Provider**: Code actions to jump from properties to their arguments
+- **Brace Matching**: Highlights matching braces in all Serilog contexts (templates, expressions, output templates)
 
 ### 🚫 Not Implemented (by design)
 - **Semantic Tokens Provider**: Replaced with decoration-based approach for better control

Example/README.md

@@ -94,6 +94,7 @@ Open `Program.cs` in Visual Studio with the Serilog Syntax extension installed t
 Colors automatically adapt for light themes with WCAG AA compliant contrast ratios - darker variants of the same color families for optimal readability on light backgrounds.
 
 ### Interactive Features
+- **Brace matching** when cursor is on `{` or `}` in any Serilog context
 - **Property-Argument highlighting** when cursor is on a property or argument
 - **Light bulb navigation** from properties to arguments
 - **Immediate highlighting** as you type (before closing quotes)

README.md

@@ -47,12 +47,19 @@ A Visual Studio Code extension that provides syntax highlighting and enhanced su
 - **Navigate to argument** - jump from template properties to their corresponding arguments
 - Click the light bulb and select "Navigate to 'PropertyName' argument"
 
+### 🔍 Brace Matching
+- **Highlight matching braces** when cursor is positioned on `{` or `}`
+- Works in all Serilog contexts: message templates, output templates, and Serilog.Expressions
+- **Multi-line support** - matches braces across line boundaries in verbatim and raw strings
+- Uses colored, bold braces for visibility without interfering with other highlighting
+
 ### 🎯 Property-Argument Highlighting
 - **Synchronous highlighting** of template properties and their corresponding arguments
 - Position cursor on a property like `{UserId}` to highlight both the property (including braces) and its argument
 - Position cursor on an argument to highlight it and its template property
 - Includes quotes when highlighting string arguments (e.g., `"userId"`)
 - Helps visualize the connection between template properties and their values
+- Uses background fill to distinguish from brace matching
 
 ## Installation
 

src/extension.ts

@@ -9,6 +9,7 @@ import { Debouncer } from './utils/debouncer';
 import { ThemeManager } from './utils/themeManager';
 import { SerilogNavigationProvider, registerNavigationCommand } from './providers/navigationProvider';
 import { PropertyArgumentHighlighter } from './providers/propertyArgumentHighlighter';
+import { SerilogBraceMatchProvider } from './providers/braceMatchProvider';
 
 export function activate(context: vscode.ExtensionContext) {
     // Create output channel for logging
@@ -59,6 +60,10 @@ export function activate(context: vscode.ExtensionContext) {
     const propertyArgumentHighlighter = new PropertyArgumentHighlighter();
     context.subscriptions.push(propertyArgumentHighlighter);
 
+    // Initialize brace match provider
+    const braceMatchProvider = new SerilogBraceMatchProvider();
+    context.subscriptions.push(braceMatchProvider);
+
     function updateDecorations() {
         const config = vscode.workspace.getConfiguration('serilog');
         const enabled = config.get<boolean>('enabled', true);
@@ -379,13 +384,15 @@ export function activate(context: vscode.ExtensionContext) {
     // Listen for cursor position changes to update brace matching
     vscode.window.onDidChangeTextEditorSelection(event => {
         if (event.textEditor === vscode.window.activeTextEditor) {
+            braceMatchProvider.updateBraceMatching(event.textEditor);
         }
     }, null, context.subscriptions);
 
     // Listen for active editor changes
     vscode.window.onDidChangeActiveTextEditor(editor => {
         if (editor) {
             updateDecorations();
+            braceMatchProvider.updateBraceMatching(editor);
         }
     }, null, context.subscriptions);
 

src/parsers/templateParser.ts

@@ -9,22 +9,44 @@ export interface TemplateProperty {
 
 export function parseTemplate(template: string): TemplateProperty[] {
     const properties: TemplateProperty[] = [];
+
     // First remove escaped braces from consideration
     const cleanedTemplate = template.replace(/\{\{|\}\}/g, '  ');
-    const regex = /\{([@$])?([A-Za-z_][A-Za-z0-9_]*|\d+)(,([+-]?\d+))?(:[^}]+)?\}/g;
+
+    const regex = /\{([@$#])?([A-Za-z_][A-Za-z0-9_]*|\d+)(,([+-]?\d+))?(:[^}]+)?\}/g;
     let match;
 
     while ((match = regex.exec(cleanedTemplate)) !== null) {
+        const prefix = match[1];
+        const name = match[2];
+
+        // Skip expression directives (start with #)
+        if (prefix === '#') {
+            continue;
+        }
+
+        // Skip expression built-ins (@t, @m, @l, @x, @i, @p)
+        // BUT ONLY for property-argument highlighting purposes
+        // Brace matching should still work on these!
+        if (prefix === '@' && ['t', 'm', 'l', 'x', 'i', 'p'].includes(name)) {
+            continue;
+        }
+
+        // Skip expression variables ($x, $y, etc. - single letter)
+        if (prefix === '$' && name.length === 1) {
+            continue;
+        }
+
         const property: TemplateProperty = {
-            name: match[2],
+            name: name,
             startIndex: match.index,
             endIndex: match.index + match[0].length,
             type: 'standard'
         };
 
-        if (match[1] === '@') property.type = 'destructured';
-        else if (match[1] === '$') property.type = 'stringified';
-        else if (/^\d+$/.test(match[2])) property.type = 'positional';
+        if (prefix === '@') property.type = 'destructured';
+        else if (prefix === '$') property.type = 'stringified';
+        else if (/^\d+$/.test(name)) property.type = 'positional';
 
         if (match[4]) property.alignment = match[4];
         if (match[5]) property.formatSpecifier = match[5].substring(1);