fix: Exclude ExpressionTemplate contexts from property-argument highlighting

Property-argument highlighting no longer triggers on ExpressionTemplate
built-in properties like {@t}, {@l}, {@m}, {@x} since these don't have
corresponding arguments to highlight. Adds test to verify the fix.

Also refactored to use SerilogCallDetector and StringLiteralParser
utilities to eliminate duplicate regex patterns

Author: willibrandon

SerilogSyntax.Tests/Tagging/PropertyArgumentHighlighterTests.cs

@@ -991,4 +991,43 @@ public void HighlightComplexNestedArguments()
         // Assert
         Assert.Equal(2, tags.Count); // Should highlight items.Count() and {Count}
     }
+
+    [Fact]
+    public void ExpressionTemplate_BuiltInProperties_ShouldNotBeHighlighted()
+    {
+        // Arrange - ExpressionTemplate with built-in properties that don't have arguments
+        var text = @".WriteTo.Console(new ExpressionTemplate(
+        ""[{@t:HH:mm:ss} {@l:u3}] {#if SourceContext is not null}[{Substring(SourceContext, LastIndexOf(SourceContext, '.') + 1)}]{#end} {@m}\n{@x}""))";
+        var buffer = MockTextBuffer.Create(text);
+        var view = new MockTextView(buffer);
+        var highlighter = new PropertyArgumentHighlighter(view, buffer);
+
+        // Act - position cursor on the opening brace of {@t:HH:mm:ss}
+        var cursorPosition = text.IndexOf("{@t:");
+        view.Caret.MoveTo(new SnapshotPoint(buffer.CurrentSnapshot, cursorPosition));
+
+        var tags = highlighter.GetTags(new NormalizedSnapshotSpanCollection(
+            new SnapshotSpan(buffer.CurrentSnapshot, 0, buffer.CurrentSnapshot.Length))).ToList();
+
+        // Assert - No tags should be created since {@t:HH:mm:ss} is not a property with an argument
+        Assert.Empty(tags);
+
+        // Also test cursor on {@l:u3}
+        cursorPosition = text.IndexOf("{@l:");
+        view.Caret.MoveTo(new SnapshotPoint(buffer.CurrentSnapshot, cursorPosition));
+
+        tags = highlighter.GetTags(new NormalizedSnapshotSpanCollection(
+            new SnapshotSpan(buffer.CurrentSnapshot, 0, buffer.CurrentSnapshot.Length))).ToList();
+
+        Assert.Empty(tags);
+
+        // Also test cursor on {@m}
+        cursorPosition = text.IndexOf("{@m}");
+        view.Caret.MoveTo(new SnapshotPoint(buffer.CurrentSnapshot, cursorPosition));
+
+        tags = highlighter.GetTags(new NormalizedSnapshotSpanCollection(
+            new SnapshotSpan(buffer.CurrentSnapshot, 0, buffer.CurrentSnapshot.Length))).ToList();
+
+        Assert.Empty(tags);
+    }
 }

SerilogSyntax/Tagging/PropertyArgumentHighlighter.cs

@@ -2,6 +2,7 @@
 using Microsoft.VisualStudio.Text.Editor;
 using Microsoft.VisualStudio.Text.Tagging;
 using SerilogSyntax.Parsing;
+using SerilogSyntax.Utilities;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -14,9 +15,13 @@ namespace SerilogSyntax.Tagging;
 /// </summary>
 internal sealed class PropertyArgumentHighlighter : ITagger<TextMarkerTag>, IDisposable
 {
+    // Note: We use SerilogCallDetector for finding Serilog calls and StringLiteralParser for string extraction
+    // to avoid duplicating regex patterns and parsing logic
+
     private readonly ITextView _view;
     private readonly ITextBuffer _buffer;
     private readonly TemplateParser _parser = new();
+    private readonly StringLiteralParser _stringParser = new();
     private SnapshotPoint? _currentChar;
     private readonly List<ITagSpan<TextMarkerTag>> _currentTags = [];
     private bool _disposed;
@@ -245,10 +250,8 @@ private SerilogCallInfo FindSerilogCall(SnapshotPoint caretPoint)
         var snapshot = caretPoint.Snapshot;
         var text = snapshot.GetText();
 
-        // Use regex to find all Serilog calls
-        // This matches both direct calls (logger.Information) and chained calls (.Information after ForContext)
-        var pattern = @"(?:(?:_?logger|Log|log)\.(?:LogVerbose|LogDebug|LogInformation|LogWarning|LogError|LogCritical|LogFatal|Verbose|Debug|Information|Warning|Error|Critical|Fatal|Write|BeginScope)|\.(?:LogVerbose|LogDebug|LogInformation|LogWarning|LogError|LogCritical|LogFatal|Verbose|Debug|Information|Warning|Error|Critical|Fatal|Write))\s*\(";
-        var methodMatches = Regex.Matches(text, pattern, RegexOptions.IgnoreCase);
+        // Use SerilogCallDetector to find all Serilog calls to avoid duplicating regex patterns
+        var methodMatches = SerilogCallDetector.FindAllSerilogCalls(text);
 
         foreach (Match methodMatch in methodMatches)
         {
@@ -284,6 +287,10 @@ private SerilogCallInfo FindSerilogCall(SnapshotPoint caretPoint)
             // Extract the call content
             var callContent = text.Substring(methodEnd, callEnd - methodEnd);
 
+            // Skip ExpressionTemplate calls - they don't have argument mapping
+            if (methodMatch.Value.Contains("ExpressionTemplate"))
+                continue;
+
             // Handle LogError special case (first parameter might be exception)
             var hasException = methodMatch.Value.Contains("LogError") && HasExceptionFirstParam(callContent);
             string adjustedCallContent = callContent;
@@ -344,7 +351,7 @@ private bool HasExceptionFirstParam(string callContent)
         if (trimmedContent.StartsWith("\"") ||
             trimmedContent.StartsWith("@\"") ||
             trimmedContent.StartsWith("$\"") ||
-            Regex.IsMatch(trimmedContent, @"^@?(""{3,})"))  // Raw string literals
+            (trimmedContent.Length > 2 && trimmedContent[0] == '\"' && trimmedContent[1] == '\"' && trimmedContent[2] == '\"'))  // Raw string literals
         {
             // First parameter is a string template, no exception
             return false;
@@ -356,63 +363,83 @@ private bool HasExceptionFirstParam(string callContent)
 
     private TemplateStringInfo ExtractTemplate(string callContent)
     {
-        // Handle different string literal formats
-        int start = -1;
-        int end = -1;
-        string template = null;
-
-        // Try raw string literal (""" or more quotes for custom delimiters)
-        // Match 3 or more quotes at the start and end
-        var rawMatch = Regex.Match(callContent, @"@?(""{3,})([\s\S]*?)\1");
-        if (rawMatch.Success)
-        {
-            // For raw string literals, the template content starts after the opening quotes
-            var quoteDelimiter = rawMatch.Groups[1].Value;
-            var quoteCount = quoteDelimiter.Length;
-            start = rawMatch.Index + quoteCount;
-            template = rawMatch.Groups[2].Value;
-            end = rawMatch.Index + rawMatch.Length;
-        }
-        else
+        // Find the first string literal in the call content
+        int searchPos = 0;
+
+        // Skip whitespace at the beginning
+        while (searchPos < callContent.Length && char.IsWhiteSpace(callContent[searchPos]))
+            searchPos++;
+
+        if (searchPos >= callContent.Length)
+            return null;
+
+        // Try to parse a string literal using StringLiteralParser
+        if (_stringParser.TryParseStringLiteral(callContent, searchPos, out var result))
         {
-            // Try verbatim string (@")
-            var verbatimMatch = Regex.Match(callContent, @"@""([^""]*(?:""""[^""]*)*)""");
-            if (verbatimMatch.Success)
+            // Determine if it's a verbatim string
+            bool isVerbatim = searchPos < callContent.Length - 1 &&
+                              callContent[searchPos] == '@' &&
+                              callContent[searchPos + 1] == '"';
+
+            // For verbatim strings, we need to store the original content with "" for position mapping
+            if (isVerbatim)
             {
-                start = verbatimMatch.Index + 2; // Skip @"
-                template = verbatimMatch.Groups[1].Value.Replace("\"\"", "\"");
-                end = verbatimMatch.Index + verbatimMatch.Length;
+                // Extract the original content with escaped quotes intact
+                var originalContent = callContent.Substring(result.Start + 2, result.End - result.Start - 2);
+                var cleanedContent = originalContent.Replace("\"\"", "\"");
 
-                // For verbatim strings, store the original for position adjustment
                 return new TemplateStringInfo
                 {
-                    Template = template,
-                    RelativeStart = start,
-                    RelativeEnd = end,
-                    OriginalTemplate = verbatimMatch.Groups[1].Value,
+                    Template = cleanedContent,
+                    RelativeStart = result.Start + 2, // Skip @"
+                    RelativeEnd = result.End + 1,
+                    OriginalTemplate = originalContent,
                     IsVerbatimString = true
                 };
             }
-            else
+
+            // For raw strings, check quote count
+            int quoteCount = 0;
+            if (callContent[searchPos] == '"')
             {
-                // Try regular string
-                var regularMatch = Regex.Match(callContent, @"""([^""\\]*(?:\\.[^""\\]*)*)""");
-                if (regularMatch.Success)
+                int pos = searchPos;
+                while (pos < callContent.Length && callContent[pos] == '"')
                 {
-                    start = regularMatch.Index + 1; // Skip opening quote
-                    template = Regex.Unescape(regularMatch.Groups[1].Value);
-                    end = regularMatch.Index + regularMatch.Length;
+                    quoteCount++;
+                    pos++;
+                }
+            }
+
+            // For raw strings (3+ quotes), adjust start position
+            if (quoteCount >= 3)
+            {
+                return new TemplateStringInfo
+                {
+                    Template = result.Content,
+                    RelativeStart = result.Start + quoteCount,
+                    RelativeEnd = result.End + 1
+                };
+            }
+
+            // For regular strings, unescape the content
+            string unescapedContent = result.Content;
+            if (quoteCount == 1) // Regular string with escape sequences
+            {
+                try
+                {
+                    unescapedContent = Regex.Unescape(result.Content);
+                }
+                catch
+                {
+                    // If unescaping fails, use content as-is
                 }
             }
-        }
 
-        if (template != null)
-        {
             return new TemplateStringInfo
             {
-                Template = template,
-                RelativeStart = start,
-                RelativeEnd = end
+                Template = unescapedContent,
+                RelativeStart = result.Start + 1, // Skip opening quote
+                RelativeEnd = result.End + 1
             };
         }
 

SerilogSyntax/Tagging/SerilogBraceMatcher.cs

@@ -417,20 +417,16 @@ public IEnumerable<ITagSpan<TextMarkerTag>> GetTags(NormalizedSnapshotSpanCollec
         bool inExpressionTemplate = IsInsideExpressionTemplate(currentChar);
 
         // For single-line strings, check if we're in a Serilog context
-        // This includes checking the previous line for configuration methods like outputTemplate
         bool inSerilogContext = IsSerilogCall(lineText);
 
         // If not found on current line, check previous line for configuration patterns
+        // Use SerilogCallDetector for more robust detection
         if (!inSerilogContext && currentLine.LineNumber > 0)
         {
             var prevLine = snapshot.GetLineFromLineNumber(currentLine.LineNumber - 1);
             var prevText = prevLine.GetText();
-            // Check if previous line has outputTemplate or other configuration methods
-            if (prevText.Contains("outputTemplate") || prevText.Contains("WriteTo.") ||
-                prevText.Contains("Enrich.") || prevText.Contains("Filter."))
-            {
-                inSerilogContext = true;
-            }
+            // Use the centralized detector which has more precise pattern matching
+            inSerilogContext = SerilogCallDetector.IsSerilogCall(prevText);
         }
 
         if (!inMultiLineString && !inExpressionTemplate && !inSerilogContext)