Bugfix/atr 966 dev fix coloring part 2

src/Acuminator/Acuminator.Utilities/Acuminator.Utilities.csproj

@@ -15,6 +15,7 @@
     <RestorePackagesPath>../../packages</RestorePackagesPath>
     <Nullable>enable</Nullable>
     <WarningsAsErrors>Nullable</WarningsAsErrors>
+    <NoWarn>$(NoWarn);CS0168</NoWarn>
   </PropertyGroup>
   <PropertyGroup>
     <PackageLicenseUrl>https://github.com/Acumatica/Acuminator/blob/dev/LICENSE</PackageLicenseUrl>

src/Acuminator/Acuminator.Utilities/Common/Concurrent/ConcurrentExtensions.cs

@@ -32,44 +32,119 @@ public static void Clear<T>(this ConcurrentQueue<T>? queue)
 		}
 
 		/// <summary>
-		/// A Task extension method that attempts to await task which could be cancelled.
+		/// A Task extension method that attempts to await task which could be cancelled or faulted.
 		/// </summary>
 		/// <param name="task">The task to act on.</param>
-		/// <returns/>      
-		public async static Task<bool> TryAwait(this Task? task)
+		/// <param name="logger">(Optional) The optional logger for non cancellation exceptions.</param>
+		/// <param name="continueOnCapturedContext">(Optional) True to continue on captured context.</param>
+		/// <returns/>
+		public async static Task<bool> TryAwait(this Task? task, Action<Exception>? logger = null, 
+												bool continueOnCapturedContext = false)
 		{
 			if (task == null || task.IsCanceled || task.IsFaulted)
 				return false;
 
 			try
 			{
-				await task.ConfigureAwait(false);
+				await task.ConfigureAwait(continueOnCapturedContext);
+				return true;
+			}
+			catch (OperationCanceledException cancelledException)
+			{
+				return false;
+			}
+			catch (Exception exception)
+			{
+				logger?.Invoke(exception);
+				return false;
+			}
+		}
+
+		/// <summary>
+		/// A <see cref="ValueTask"/> extension method that attempts to await task which could be cancelled or faulted.
+		/// </summary>
+		/// <param name="task">The task to act on.</param>
+		/// <param name="logger">(Optional) The optional logger for non cancellation exceptions.</param>
+		/// <param name="continueOnCapturedContext">(Optional) True to continue on captured context.</param>
+		/// <returns/>
+		public async static ValueTask<bool> TryAwait(this ValueTask task, Action<Exception>? logger = null, 
+													 bool continueOnCapturedContext = false)
+		{
+			if (task.IsCanceled || task.IsFaulted)
+				return false;
+
+			try
+			{
+				await task.ConfigureAwait(continueOnCapturedContext);
 				return true;
 			}
-			catch (OperationCanceledException)
+			catch (OperationCanceledException cancelledException)
+			{
+				return false;
+			}
+			catch (Exception exception)
 			{
+				logger?.Invoke(exception);
 				return false;
 			}
 		}
 
 		/// <summary>
-		/// A <see cref="Task{TResult}"/> extension method that attempts to await task which could be cancelled.
+		/// A <see cref="Task{TResult}"/> extension method that attempts to await task which could be cancelled or faulted.
 		/// </summary>
 		/// <typeparam name="TResult">Type of the result.</typeparam>
 		/// <param name="task">The task to act on.</param>
+		/// <param name="logger">(Optional) The optional logger for non cancellation exceptions.</param>
+		/// <param name="continueOnCapturedContext">(Optional) True to continue on captured context.</param>
 		/// <returns/>      
-		public async static Task<TaskResult<TResult>> TryAwait<TResult>(this Task<TResult>? task)
+		public async static Task<TaskResult<TResult>> TryAwait<TResult>(this Task<TResult>? task, Action<Exception>? logger = null,
+																		bool continueOnCapturedContext = false)
 		{
 			if (task == null || task.IsCanceled || task.IsFaulted)
 				return new TaskResult<TResult>(false, default);
 
 			try
 			{
-				TResult? result = await task.ConfigureAwait(false);
+				TResult? result = await task.ConfigureAwait(continueOnCapturedContext);
 				return new TaskResult<TResult>(true, result);
 			}
-			catch (OperationCanceledException)
+			catch (OperationCanceledException cancelledException)
+			{
+				return new TaskResult<TResult>(false, default);
+			}
+			catch (Exception exception)
+			{
+				logger?.Invoke(exception);
+				return new TaskResult<TResult>(false, default);
+			}
+		}
+
+		/// <summary>
+		/// A <see cref="ValueTask{TResult}"/> extension method that attempts to await task which could be cancelled or faulted.
+		/// </summary>
+		/// <typeparam name="TResult">Type of the result.</typeparam>
+		/// <param name="task">The task to act on.</param>
+		/// <param name="logger">(Optional) The optional logger for non cancellation exceptions.</param>
+		/// <param name="continueOnCapturedContext">(Optional) True to continue on captured context.</param>
+		/// <returns/>
+		public async static ValueTask<TaskResult<TResult>> TryAwait<TResult>(this ValueTask<TResult> task, Action<Exception>? logger = null,
+																			 bool continueOnCapturedContext = false)
+		{
+			if (task.IsCanceled || task.IsFaulted)
+				return new TaskResult<TResult>(false, default);
+
+			try
+			{
+				TResult? result = await task.ConfigureAwait(continueOnCapturedContext);
+				return new TaskResult<TResult>(true, result);
+			}
+			catch (OperationCanceledException cancelledException)
+			{
+				return new TaskResult<TResult>(false, default);
+			}
+			catch (Exception exception)
 			{
+				logger?.Invoke(exception);
 				return new TaskResult<TResult>(false, default);
 			}
 		}

src/Acuminator/Acuminator.Utilities/Roslyn/Semantic/SemanticModelUtils.cs

@@ -15,10 +15,10 @@ namespace Acuminator.Utilities.Roslyn.Semantic
 	public static class SemanticModelUtils
 	{
 		/// <summary>
-		/// Safely analyse data flow for a <paramref name="node"/> and return <see cref="DataFlowAnalysis"/> if analysis succeeded.
+		/// Safely analyze data flow for a <paramref name="node"/> and return <see cref="DataFlowAnalysis"/> if analysis succeeded.
 		/// </summary>
 		/// <param name="semanticModel">The semanticModel to act on.</param>
-		/// <param name="node">The node to analyse.</param>
+		/// <param name="node">The node to analyze.</param>
 		/// <returns>
 		/// A <see cref="DataFlowAnalysis"/> if the data flow analysis succeeded, <see langword="null"/> if not.
 		/// </returns>
@@ -62,12 +62,14 @@ public static class SemanticModelUtils
 
 		[SuppressMessage("Usage", "VSTHRD103:Call async methods when in an async method", Justification = "Aggregated await is used")]
 		public static async Task<(SemanticModel? SemanticModel, SyntaxNode? Root)> GetSemanticModelAndRootAsync(this Document document, 
-																												CancellationToken cancellation = default)
+																												CancellationToken cancellation = default,
+																												bool continueOnCapturedContext = false)
 		{
 			var semanticModelTask = document.CheckIfNull().GetSemanticModelAsync(cancellation);
 			var syntaxRootTask = document.GetSyntaxRootAsync(cancellation);
 
-			await Task.WhenAll(semanticModelTask, syntaxRootTask).ConfigureAwait(false);
+			await Task.WhenAll(semanticModelTask, syntaxRootTask)
+					  .ConfigureAwait(continueOnCapturedContext);
 
 			return (semanticModelTask.Result, syntaxRootTask.Result);
 		}

src/Acuminator/Acuminator.Vsix/AcuminatorVSPackage.cs

@@ -504,9 +504,6 @@ private static void DeployCodeSnippets(AcuminatorMyDocumentsStorage? myDocuments
 		#region Package Settings
 		public bool ColoringEnabled => GeneralOptionsPage?.ColoringEnabled ?? AcuminatorConstants.Settings.Coloring.ColoringEnabledDefault;
 
-
-		public bool UseRegexColoring => GeneralOptionsPage?.UseRegexColoring ?? AcuminatorConstants.Settings.Coloring.UseRegexColoringDefault;
-
 		public bool UseBqlOutlining => GeneralOptionsPage?.UseBqlOutlining ?? AcuminatorConstants.Settings.Outlining.UseBqlOutliningDefault;
 
 		public bool UseBqlDetailedOutlining => 

src/Acuminator/Acuminator.Vsix/BannedApi/BannedApiDeployer.cs

@@ -35,7 +35,7 @@ private BannedApiDeployer(AcuminatorMyDocumentsStorage myDocumentsStorage, strin
 				return null;
 			try
 			{
-				string bannedApiFolder = Path.Combine(myDocumentsStorage.AcuminatorFolder, Constants.BannedApi.BannnedApiFolder);
+				string bannedApiFolder = Path.Combine(myDocumentsStorage.AcuminatorFolder, Constants.BannedApi.BannedApiFolder);
 				return new BannedApiDeployer(myDocumentsStorage, bannedApiFolder);
 			}
 			catch (Exception e)

src/Acuminator/Acuminator.Vsix/Coloriser/AsyncTagging/BackgroundTagging.cs

@@ -1,7 +1,5 @@
 #nullable enable
-
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
@@ -13,10 +11,9 @@
 
 namespace Acuminator.Vsix.Coloriser
 {
-	public class BackgroundTagging : IDisposable
+	internal class BackgroundTagging : IDisposable
 	{
-		private static TaskScheduler? _vsTaskScheduler;
-
+		private static TaskScheduler? _vsTaskScheduler; 
 		private CancellationTokenSource _cancellationTokenSource = new();
 
 		public CancellationToken CancellationToken => _cancellationTokenSource.Token;
@@ -27,10 +24,9 @@ public class BackgroundTagging : IDisposable
 
 		private BackgroundTagging()
 		{
-
 		}
 
-		public static BackgroundTagging StartBackgroundTagging(PXColorizerTaggerBase tagger)
+		public static BackgroundTagging StartBackgroundTagging(PXRoslynColorizerTagger tagger)
 		{
 			tagger.ThrowOnNull();
 
@@ -48,10 +44,22 @@ public static BackgroundTagging StartBackgroundTagging(PXColorizerTaggerBase tag
 			// No need for synchronization because FromCurrentSynchronizationContext creates schedulers which wrap around the same synchronization context
 			// Therefore all schedulers should be identical and nothing wrong will happen if different thread will create multiple instance of the scheduler in a race condition
 			_vsTaskScheduler = _vsTaskScheduler ?? TaskScheduler.FromCurrentSynchronizationContext();
-			backgroundTagging.TaggingTask = taggingTask.ContinueWith(task => AfterTaggingActionAsync(tagger, backgroundTagging.CancellationToken),  //continuation should be on the UI thread
+			var continuationTask = taggingTask.ContinueWith(task => AfterTaggingActionAsync(task, tagger, backgroundTagging.CancellationToken),  //continuation should be on the UI thread
 																	 backgroundTagging.CancellationToken,
-																	 TaskContinuationOptions.OnlyOnRanToCompletion,
+																	 TaskContinuationOptions.NotOnCanceled,
 																	 _vsTaskScheduler);
+
+			// ContinueWith schedules the lambda on the VS UI thread scheduler. The lambda runs on the UI thread and calls AfterTaggingActionAsync(...).
+			// Inside AfterTaggingActionAsync, the important path calls ThreadHelper.JoinableTaskFactory.RunAsync(tagger.RaiseTagsChangedAsync).Task 
+			// this starts RaiseTagsChangedAsync and immediately returns the underlying Task representing it (still running).
+			// The lambda returns that inner Task immediately — it does not await it.
+			// The outer Task<Task> stored in TaggingTask is marked as Completed (RanToCompletion) at this point, because the lambda has returned. 
+			// The outer task's result is the still-running inner task, but the outer task itself is done.
+			// RaiseTagsChangedAsync may still be running in the background raising tags-changed notifications. 
+			// 
+			// Thus, we need to keep the nested unwrapped task as the tagging task to be able to correctly calculate IsTaskRunning() and 
+			// handle exceptions thrown in the AfterTaggingActionAsync.
+			backgroundTagging.TaggingTask = continuationTask.Unwrap();
 			return backgroundTagging;
 		}
 
@@ -76,12 +84,21 @@ public void Dispose()
 			_cancellationTokenSource.Dispose();
 		}
 
-		private static Task AfterTaggingActionAsync(PXColorizerTaggerBase tagger, CancellationToken cancellationToken)
+		private static Task AfterTaggingActionAsync(Task taggingTask, PXRoslynColorizerTagger tagger, CancellationToken cancellationToken)
 		{
-			if (cancellationToken.IsCancellationRequested)
+			if (taggingTask.IsCanceled || cancellationToken.IsCancellationRequested)
+			{
+				tagger.LastTaggingWasSuccessful = false;
 				return Task.FromCanceled(cancellationToken);
-
-			// We should be on UI thread here but the tagger.RaiseTagsChangedAsync switches to UI thread from non UI threads internally if needed         
+			}
+
+			if (taggingTask.IsFaulted)
+			{
+				tagger.LastTaggingWasSuccessful = false;
+				return Task.FromException(taggingTask.Exception!);
+			}
+
+			// We should be on UI thread here but the tagger.RaiseTagsChangedAsync switches to UI thread from non UI threads internally if needed
 			return Shell.ThreadHelper.JoinableTaskFactory.RunAsync(tagger.RaiseTagsChangedAsync).Task;
 		}
 	}