fix: Add ESC key dismissal for property-argument highlighting

Implements ESC key dismissal for property-argument highlights following the same pattern as brace matching. Highlights automatically restore when cursor moves.

- Created PropertyArgumentHighlightState for per-view dismissal tracking
- Added PropertyArgumentEscCommandHandler to handle ESC in command chain
- Updated PropertyArgumentHighlighter to respect dismissal state

Author: willibrandon

CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.7.1] - 2025-09-21
+
+### Fixed
+- Added ESC key dismissal for property-argument highlighting
+  - Press ESC to temporarily dismiss property-argument highlights
+  - Highlights automatically restore when cursor moves to a new position
+  - Consistent with brace matching ESC dismissal behavior
+  - Uses Visual Studio command handler chain for proper key handling
+
 ## [0.7.0] - 2025-09-21
 
 ### Added

SerilogSyntax.Tests/Tagging/PropertyArgumentHighlighterTests.cs

@@ -1016,17 +1016,17 @@ public void ExpressionTemplate_BuiltInProperties_ShouldNotBeHighlighted()
         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();
+        tags = [.. highlighter.GetTags(new NormalizedSnapshotSpanCollection(
+            new SnapshotSpan(buffer.CurrentSnapshot, 0, buffer.CurrentSnapshot.Length)))];
 
         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();
+        tags = [.. highlighter.GetTags(new NormalizedSnapshotSpanCollection(
+            new SnapshotSpan(buffer.CurrentSnapshot, 0, buffer.CurrentSnapshot.Length)))];
 
         Assert.Empty(tags);
     }

SerilogSyntax/SerilogSyntax.csproj

@@ -72,8 +72,10 @@
     <Compile Include="Parsing\TemplateProperty.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="SerilogSyntaxPackage.cs" />
+    <Compile Include="Tagging\PropertyArgumentEscCommandHandler.cs" />
     <Compile Include="Tagging\PropertyArgumentHighlighter.cs" />
     <Compile Include="Tagging\PropertyArgumentHighlighterProvider.cs" />
+    <Compile Include="Tagging\PropertyArgumentHighlightState.cs" />
     <Compile Include="Tagging\SerilogBraceMatcher.cs" />
     <Compile Include="Tagging\SerilogBraceHighlightState.cs" />
     <Compile Include="Tagging\SerilogBraceEscCommandHandler.cs" />

SerilogSyntax/Tagging/PropertyArgumentEscCommandHandler.cs

@@ -0,0 +1,52 @@
+using Microsoft.VisualStudio.Commanding;
+using Microsoft.VisualStudio.Text.Editor.Commanding.Commands;
+using Microsoft.VisualStudio.Utilities;
+using System.ComponentModel.Composition;
+
+namespace SerilogSyntax.Tagging
+{
+    /// <summary>
+    /// Handles ESC to dismiss the property-argument highlights.
+    /// Participates in the editor command chain.
+    /// </summary>
+    [Export(typeof(ICommandHandler))]
+    [Name("PropertyArgumentEscHandler")]
+    [ContentType("CSharp")]
+    internal sealed class PropertyArgumentEscCommandHandler
+        : IChainedCommandHandler<EscapeKeyCommandArgs>
+    {
+        /// <summary>
+        /// Gets the display name of the command handler.
+        /// </summary>
+        public string DisplayName => "Property-Argument ESC Dismissal";
+
+        /// <summary>
+        /// Executes the ESC command, dismissing property-argument highlights if applicable.
+        /// </summary>
+        /// <param name="args">The ESC key command arguments.</param>
+        /// <param name="nextHandler">The next handler in the command chain.</param>
+        /// <param name="context">The command execution context.</param>
+        public void ExecuteCommand(EscapeKeyCommandArgs args, System.Action nextHandler, CommandExecutionContext context)
+        {
+            var view = args.TextView;
+            var state = PropertyArgumentHighlightState.GetOrCreate(view);
+
+            // Only handle ESC if we actually dismiss something; otherwise, pass through.
+            bool handled = state.Dismiss();
+            if (!handled)
+                nextHandler();
+        }
+
+        /// <summary>
+        /// Gets the command state for the ESC key.
+        /// </summary>
+        /// <param name="args">The ESC key command arguments.</param>
+        /// <param name="nextHandler">The next handler in the command chain.</param>
+        /// <returns>The command state.</returns>
+        public CommandState GetCommandState(EscapeKeyCommandArgs args, System.Func<CommandState> nextHandler)
+        {
+            // Enabled whenever we can access the view; we decide to handle at ExecuteCommand time.
+            return CommandState.Available;
+        }
+    }
+}

SerilogSyntax/Tagging/PropertyArgumentHighlightState.cs

@@ -0,0 +1,86 @@
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using System;
+
+namespace SerilogSyntax.Tagging
+{
+    /// <summary>
+    /// Per-view state for property-argument highlighting, including ESC dismissal.
+    /// </summary>
+    internal sealed class PropertyArgumentHighlightState : IDisposable
+    {
+        private readonly ITextView _view;
+
+        // Track whether highlighting is currently dismissed
+        private bool _isDismissed;
+
+        /// <summary>
+        /// Occurs when the highlight state changes (dismissal or restoration).
+        /// </summary>
+        public event EventHandler StateChanged;
+
+        public PropertyArgumentHighlightState(ITextView view)
+        {
+            _view = view ?? throw new ArgumentNullException(nameof(view));
+            _view.Closed += OnViewClosed;
+            _view.Caret.PositionChanged += OnCaretPositionChanged;
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether highlighting has been dismissed via ESC.
+        /// </summary>
+        public bool IsDismissed => _isDismissed;
+
+        /// <summary>
+        /// Dismisses the property-argument highlights.
+        /// Called by the ESC command handler.
+        /// </summary>
+        /// <returns>True if highlights were dismissed; false if already dismissed.</returns>
+        public bool Dismiss()
+        {
+            if (_isDismissed)
+                return false; // Already dismissed, let other ESC handlers run
+
+            _isDismissed = true;
+            OnStateChanged();
+            return true;
+        }
+
+        /// <summary>
+        /// Restores highlighting after being dismissed.
+        /// Called when the caret position changes.
+        /// </summary>
+        public void Restore()
+        {
+            if (_isDismissed)
+            {
+                _isDismissed = false;
+                OnStateChanged();
+            }
+        }
+
+        private void OnCaretPositionChanged(object sender, CaretPositionChangedEventArgs e)
+        {
+            // Restore highlighting when cursor moves after ESC dismissal
+            Restore();
+        }
+
+        private void OnStateChanged() => StateChanged?.Invoke(this, EventArgs.Empty);
+
+        private void OnViewClosed(object sender, EventArgs e) => Dispose();
+
+        public void Dispose()
+        {
+            _view.Closed -= OnViewClosed;
+            _view.Caret.PositionChanged -= OnCaretPositionChanged;
+        }
+
+        /// <summary>
+        /// Gets or creates a singleton instance of the state for the specified view.
+        /// </summary>
+        /// <param name="view">The text view.</param>
+        /// <returns>The state instance for the view.</returns>
+        public static PropertyArgumentHighlightState GetOrCreate(ITextView view)
+            => view.Properties.GetOrCreateSingletonProperty(() => new PropertyArgumentHighlightState(view));
+    }
+}

SerilogSyntax/Tagging/PropertyArgumentHighlighter.cs

@@ -25,6 +25,7 @@ internal sealed class PropertyArgumentHighlighter : ITagger<TextMarkerTag>, IDis
     private SnapshotPoint? _currentChar;
     private readonly List<ITagSpan<TextMarkerTag>> _currentTags = [];
     private bool _disposed;
+    private readonly PropertyArgumentHighlightState _state;
 
     public event EventHandler<SnapshotSpanEventArgs> TagsChanged;
 
@@ -35,6 +36,10 @@ public PropertyArgumentHighlighter(ITextView view, ITextBuffer buffer)
 
         _currentChar = view.Caret.Position.Point.GetPoint(buffer, view.Caret.Position.Affinity);
 
+        // Set up state tracking for ESC dismissal
+        _state = PropertyArgumentHighlightState.GetOrCreate(_view);
+        _state.StateChanged += OnStateChanged;
+
         _view.Caret.PositionChanged += CaretPositionChanged;
         _view.LayoutChanged += ViewLayoutChanged;
     }
@@ -48,6 +53,14 @@ private void ViewLayoutChanged(object sender, TextViewLayoutChangedEventArgs e)
             UpdateAtCaretPosition(_view.Caret.Position);
     }
 
+    private void OnStateChanged(object sender, EventArgs e)
+    {
+        // When state changes (ESC dismiss/restore), refresh tags
+        var snapshot = _buffer.CurrentSnapshot;
+        var fullSpan = new SnapshotSpan(snapshot, 0, snapshot.Length);
+        TagsChanged?.Invoke(this, new SnapshotSpanEventArgs(fullSpan));
+    }
+
     private void UpdateAtCaretPosition(CaretPosition caretPosition)
     {
         _currentChar = caretPosition.Point.GetPoint(_buffer, caretPosition.Affinity);
@@ -533,7 +546,7 @@ private List<ArgumentInfo> ExtractArguments(string callContent, int templateEnd,
 
     public IEnumerable<ITagSpan<TextMarkerTag>> GetTags(NormalizedSnapshotSpanCollection spans)
     {
-        if (_disposed || spans.Count == 0)
+        if (_disposed || spans.Count == 0 || _state?.IsDismissed == true)
             return [];
 
         return _currentTags.Where(tag => spans.Any(span => span.IntersectsWith(tag.Span)));
@@ -572,6 +585,11 @@ public void Dispose()
         if (_disposed) return;
         _disposed = true;
 
+        if (_state != null)
+        {
+            _state.StateChanged -= OnStateChanged;
+        }
+
         if (_view != null)
         {
             _view.Caret.PositionChanged -= CaretPositionChanged;

SerilogSyntax/Tagging/SerilogBraceEscCommandHandler.cs

@@ -1,5 +1,4 @@
 using Microsoft.VisualStudio.Commanding;
-using Microsoft.VisualStudio.Text.Editor;
 using Microsoft.VisualStudio.Text.Editor.Commanding.Commands;
 using Microsoft.VisualStudio.Utilities;
 using System.ComponentModel.Composition;