Exception handling refactoring

DevTeam · Jun 6, 2024 · 17905b0 · 17905b0
1 parent 8d302b1
commit 17905b0
Show file tree

Hide file tree

Showing 5 changed files with 108 additions and 59 deletions.
diff --git a/src/Pure.DI.Core/Core/ExceptionHandler.cs b/src/Pure.DI.Core/Core/ExceptionHandler.cs
@@ -0,0 +1,79 @@
+namespace Pure.DI.Core;
+
+internal class ExceptionHandler(ILogger<ExceptionHandler> logger)
+    : IExceptionHandler
+{
+    public void SafeRun<T>(T state, Action<T> action)
+    {
+        try
+        {
+            action(state);
+        }
+        catch (AggregateException aggregateException)
+        {
+            OnAggregateException(aggregateException);
+        }
+        catch (CompileErrorException compileException)
+        {
+            OnCompileException(compileException);
+        }
+        catch (HandledException handledException)
+        {
+            OnHandledException(handledException);
+        }
+        catch (OperationCanceledException)
+        {
+            throw;
+        }
+        catch (Exception exception)
+        {
+            OnException(exception);
+        }
+    }
+
+    private void OnAggregateException(AggregateException aggregateException)
+    {
+        foreach (var exception in aggregateException.InnerExceptions)
+        {
+            switch (exception)
+            {
+                case CompileErrorException compileError:
+                    OnCompileException(compileError);
+                    break;
+
+                case HandledException handledException:
+                    OnHandledException(handledException);
+                    break;
+
+                default:
+                    OnException(exception);
+                    break;
+            }
+        }
+    }
+
+    private void OnCompileException(CompileErrorException exception) => 
+        logger.CompileError(exception.ErrorMessage, exception.Location, exception.Id);
+
+    private void OnHandledException(HandledException handledException) =>
+        logger.Log(
+            new LogEntry(
+#if DEBUG
+                DiagnosticSeverity.Info,
+#else
+                DiagnosticSeverity.Hidden,
+#endif
+                "Code generation aborted.",
+                default,
+                LogId.InfoGenerationInterrupted,
+                handledException));
+
+    private void OnException(Exception exception) =>
+        logger.Log(
+            new LogEntry(
+                DiagnosticSeverity.Error,
+                "An unhandled error has occurred.",
+                default,
+                LogId.ErrorUnhandled,
+                exception));
+}
diff --git a/src/Pure.DI.Core/Core/Generator.cs b/src/Pure.DI.Core/Core/Generator.cs
@@ -4,11 +4,12 @@ namespace Pure.DI.Core;
 internal sealed class Generator(
     IGlobalOptions globalOptions,
     IProfiler profiler,
-    ILogger<Generator> logger,
+    IExceptionHandler exceptionHandler,
     IObserversRegistry observersRegistry,
     IObserver<LogEntry> logObserver,
     IBuilder<IEnumerable<SyntaxUpdate>, IEnumerable<MdSetup>> metadataBuilder,
-    Func<IBuilder<MdSetup, Unit>> codeBuilderFactory)
+    Func<IBuilder<MdSetup, Unit>> codeBuilderFactory,
+    CancellationToken cancellationToken)
     : IBuilder<IEnumerable<SyntaxUpdate>, Unit>
 {
     public Unit Build(IEnumerable<SyntaxUpdate> updates)
@@ -21,67 +22,29 @@ public Unit Build(IEnumerable<SyntaxUpdate> updates)
         using var logObserverToken= observersRegistry.Register(logObserver);
         try
         {
-            foreach (var setup in metadataBuilder.Build(updates))
-            {
-                try
-                {
-                    codeBuilderFactory().Build(setup);
-                }
-                catch (CompileErrorException compileException)
-                {
-                    OnCompileException(compileException);
-                }
-                catch (HandledException handledException)
-                {
-                    OnHandledException(handledException);
-                }
-            }
-        }
-        catch (OperationCanceledException)
-        {
-        }
-        catch (CompileErrorException compileException)
-        {
-            OnCompileException(compileException);
-        }
-        catch (HandledException handledException)
-        {
-            OnHandledException(handledException);
-        }
-        catch (Exception exception)
-        {
-            OnException(exception);
+            exceptionHandler.SafeRun(updates, ProcessUpdates);
         }
         finally
         {
             logObserver.OnCompleted();
         }
-        
+
         return Unit.Shared;
     }
+
+    private void ProcessUpdates(IEnumerable<SyntaxUpdate> updates)
+    {
+        foreach (var setup in metadataBuilder.Build(updates))
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                break;
+            }
 
-    private void OnCompileException(CompileErrorException exception) => 
-        logger.CompileError(exception.ErrorMessage, exception.Location, exception.Id);
-
-    private void OnHandledException(Exception handledException) =>
-        logger.Log(
-            new LogEntry(
-#if DEBUG
-                DiagnosticSeverity.Info,
-#else
-                DiagnosticSeverity.Hidden,
-#endif
-                "Code generation aborted.",
-                default,
-                LogId.InfoGenerationInterrupted,
-                handledException));
-
-    private void OnException(Exception exception) =>
-        logger.Log(
-            new LogEntry(
-                DiagnosticSeverity.Error,
-                "An unhandled error has occurred.",
-                default,
-                LogId.ErrorUnhandled,
-                exception));
+            exceptionHandler.SafeRun(setup, BuildCode);
+        }
+    }
+
+    private void BuildCode(MdSetup setup) =>
+        codeBuilderFactory().Build(setup);
 }
diff --git a/src/Pure.DI.Core/Core/IExceptionHandler.cs b/src/Pure.DI.Core/Core/IExceptionHandler.cs
@@ -0,0 +1,6 @@
+namespace Pure.DI.Core;
+
+internal interface IExceptionHandler
+{
+    void SafeRun<T>(T state, Action<T> action);
+}
diff --git a/src/Pure.DI.Core/Core/MetadataSyntaxWalker.cs b/src/Pure.DI.Core/Core/MetadataSyntaxWalker.cs
@@ -46,8 +46,8 @@ public void Visit(IMetadataVisitor metadataVisitor, in SyntaxUpdate update)
         visitors.Reverse();
 #if DEBUG
         visitors.ForEach(i => ProcessInvocation(i));
-#else 
-        Parallel.ForEach(visitors, i => ProcessInvocation(i));
+#else
+        Parallel.ForEach(visitors, new ParallelOptions() { CancellationToken = cancellationToken }, i => ProcessInvocation(i));
 #endif
         foreach (var visitor in visitors)
         {

diff --git a/src/Pure.DI.Core/Generator.Composition.cs b/src/Pure.DI.Core/Generator.Composition.cs
@@ -60,6 +60,7 @@ private void Setup() => DI.Setup(nameof(Generator))
             .Bind().To<Formatter>()
             .Bind().To<NodeInfo>()
             .Bind<IEqualityComparer<INamedTypeSymbol>>().To<NamedTypeSymbolEqualityComparer>()
+            .Bind().To<ExceptionHandler>()
 
             // Validators
             .Bind(Tag.Type).To<MetadataValidator>()