Merge pull request #9864 from drewnoakes/remove-watson-reporting

drewnoakes · web-flow · commit c51353e5866e · 2025-11-25T12:35:45.000+11:00
Remove Watson report settings
diff --git a/src/Common/BannedSymbols.txt b/src/Common/BannedSymbols.txt
@@ -54,10 +54,6 @@ M:Microsoft.VisualStudio.Threading.TplExtensions.Forget(System.Threading.Tasks.T
 M:Microsoft.VisualStudio.Shell.VsTaskLibraryHelper.FileAndForget(System.Threading.Tasks.Task,System.String,System.String,System.Func{System.Exception,System.Boolean}); Use IProjectFaultHandlerService.Forget to ensure that failed tasks are reported as non-fatal watsons and assigned to the correct component
 M:Microsoft.VisualStudio.Shell.VsTaskLibraryHelper.FileAndForget(Microsoft.VisualStudio.Threading.JoinableTask,System.String,System.String,System.Func{System.Exception,System.Boolean}); Use IProjectFaultHandlerService.Forget to ensure that failed tasks are reported as non-fatal watsons and assigned to the correct component
 
-M:Microsoft.VisualStudio.ProjectSystem.IProjectFaultHandlerService.HandleFaultAsync(System.Exception,Microsoft.VisualStudio.ProjectSystem.ErrorReportSettings,Microsoft.VisualStudio.ProjectSystem.ProjectFaultSeverity,Microsoft.VisualStudio.ProjectSystem.UnconfiguredProject); Use IProjectFaultHandlerService.ReportFaultAsync to ensure that failed tasks are reported as non-fatal watsons and assigned to the correct component
-M:Microsoft.VisualStudio.ProjectSystem.IProjectFaultHandlerService.RegisterFaultHandler(System.Threading.Tasks.Task,Microsoft.VisualStudio.ProjectSystem.ErrorReportSettings,Microsoft.VisualStudio.ProjectSystem.ProjectFaultSeverity,Microsoft.VisualStudio.ProjectSystem.UnconfiguredProject); Use IProjectFaultHandlerService.Forget to ensure that failed tasks are reported as non-fatal watsons and assigned to the correct component
-M:Microsoft.VisualStudio.ProjectSystem.IProjectFaultHandlerService.RegisterFaultHandler`1(System.Threading.Tasks.Task{``0},Microsoft.VisualStudio.ProjectSystem.ErrorReportSettings,Microsoft.VisualStudio.ProjectSystem.ProjectFaultSeverity,Microsoft.VisualStudio.ProjectSystem.UnconfiguredProject); Use IProjectFaultHandlerService.Forget to ensure that failed tasks are reported as non-fatal watsons and assigned to the correct component
-
 M:Microsoft.VisualStudio.Telemetry.PostFault(Microsoft.VisualStudio.Telemetry.TelemetrySession,System.String,System.String);Use IProjectFaultHandlerService.Forget to ensure that failed tasks are reported as non-fatal watsons and assigned to the correct component
 M:Microsoft.VisualStudio.Telemetry.PostFault(Microsoft.VisualStudio.Telemetry.TelemetrySession,System.String,System.String,System.Exception);Use IProjectFaultHandlerService.Forget to ensure that failed tasks are reported as non-fatal watsons and assigned to the correct component
 M:Microsoft.VisualStudio.Telemetry.PostFault(Microsoft.VisualStudio.Telemetry.TelemetrySession,System.String,System.String,System.Exception,System.Func{Microsoft.VisualStudio.Telemetry.IFaultUtility,System.Int32});Use IProjectFaultHandlerService.Forget to ensure that failed tasks are reported as non-fatal watsons and assigned to the correct component
diff --git a/src/Microsoft.VisualStudio.ProjectSystem.Managed.VS/ProjectSystem/VS/Debug/LaunchProfilesDebugLaunchProvider.cs b/src/Microsoft.VisualStudio.ProjectSystem.Managed.VS/ProjectSystem/VS/Debug/LaunchProfilesDebugLaunchProvider.cs
@@ -168,22 +168,22 @@ public void OnComplete(int hr, uint debugTargetCount, VsDebugTargetProcessInfo[]
                     processInfoArray.Length == 1 &&
                     vsLaunchedProcess is not null)
                 {
-                    projectFaultHandlerService.Forget(
+                    projectFaultHandlerService.RegisterFaultHandler(
                         targetsProvider5.OnAfterLaunchAsync(launchOptions, activeProfile, debugLaunchSettings[0], vsLaunchedProcess, processInfoArray[0]),
-                        unconfiguredProject);
+                        project: unconfiguredProject);
                 }
                 else
                 {
-                    projectFaultHandlerService.Forget(
+                    projectFaultHandlerService.RegisterFaultHandler(
                         targetsProvider4.OnAfterLaunchAsync(launchOptions, activeProfile, processInfoArray),
-                        unconfiguredProject);
+                        project: unconfiguredProject);
                 }
             }
             else if (targetsProvider is not null)
             {
-                projectFaultHandlerService.Forget(
+                projectFaultHandlerService.RegisterFaultHandler(
                     targetsProvider.OnAfterLaunchAsync(launchOptions, activeProfile),
-                    unconfiguredProject);
+                    project: unconfiguredProject);
             }
         }
 
diff --git a/src/Microsoft.VisualStudio.ProjectSystem.Managed.VS/ProjectSystem/VS/LanguageServices/LanguageServiceHost.cs b/src/Microsoft.VisualStudio.ProjectSystem.Managed.VS/ProjectSystem/VS/LanguageServices/LanguageServiceHost.cs
@@ -162,7 +162,7 @@ protected override async Task InitializeCoreAsync(CancellationToken cancellation
                 _firstPrimaryWorkspaceSet.TrySetException(ex);
 
                 // Report the exception as an NFE that limits the functionality of the project.
-                _ = _projectFaultHandler.ReportFaultAsync(ex, _unconfiguredProject, ProjectFaultSeverity.LimitedFunctionality);
+                _ = _projectFaultHandler.HandleFaultAsync(ex, project: _unconfiguredProject, severity: ProjectFaultSeverity.LimitedFunctionality);
             },
             CancellationToken.None,
             TaskContinuationOptions.OnlyOnFaulted,
@@ -360,7 +360,7 @@ public async Task AfterLoadInitialConfigurationAsync()
 
             // While we want make sure it's loaded before PrioritizedProjectLoadedInHost,
             // we don't want to block project factory completion on its load, so fire and forget.
-            _projectFaultHandler.Forget(result, _unconfiguredProject, ProjectFaultSeverity.LimitedFunctionality);
+            _projectFaultHandler.RegisterFaultHandler(result, project: _unconfiguredProject, severity: ProjectFaultSeverity.LimitedFunctionality);
         }
     }
 
diff --git a/src/Microsoft.VisualStudio.ProjectSystem.Managed.VS/ProjectSystem/VS/LanguageServices/Workspace.cs b/src/Microsoft.VisualStudio.ProjectSystem.Managed.VS/ProjectSystem/VS/LanguageServices/Workspace.cs
@@ -304,7 +304,7 @@ async Task ProcessInitialEvaluationDataAsync(CancellationToken cancellationToken
             {
                 _state = WorkspaceState.Failed;
 
-                await _faultHandlerService.ReportFaultAsync(ex, _unconfiguredProject, ProjectFaultSeverity.LimitedFunctionality);
+                await _faultHandlerService.HandleFaultAsync(ex, project: _unconfiguredProject, severity: ProjectFaultSeverity.LimitedFunctionality);
 
                 _context?.Dispose();
 
diff --git a/src/Microsoft.VisualStudio.ProjectSystem.Managed.VS/ProjectSystem/VS/PackageRestore/NuGetRestoreService.cs b/src/Microsoft.VisualStudio.ProjectSystem.Managed.VS/ProjectSystem/VS/PackageRestore/NuGetRestoreService.cs
@@ -232,6 +232,6 @@ private void RegisterProjectRestoreInfoSource()
         });
 #pragma warning restore RS0030 // Do not used banned APIs
 
-        _faultHandlerService.Forget(registerRestoreInfoSourceTask, _project, ProjectFaultSeverity.Recoverable);
+        _faultHandlerService.RegisterFaultHandler(registerRestoreInfoSourceTask, project: _project);
     }
 }
diff --git a/src/Microsoft.VisualStudio.ProjectSystem.Managed.VS/ProjectSystem/VS/Setup/SetupComponentProvider.cs b/src/Microsoft.VisualStudio.ProjectSystem.Managed.VS/ProjectSystem/VS/Setup/SetupComponentProvider.cs
@@ -57,7 +57,7 @@ public Task LoadAsync()
         // Don't block on initialization here. It doesn't need to complete before we continue here,
         // and initialization will wait on some features of the project to become available, which would
         // cause a deadlock if we waited here. We file this so any exception is reported as an NFE.
-        _projectFaultHandlerService.Forget(task, _unconfiguredProject, ProjectFaultSeverity.LimitedFunctionality);
+        _projectFaultHandlerService.RegisterFaultHandler(task, project: _unconfiguredProject, severity: ProjectFaultSeverity.LimitedFunctionality);
 
         return Task.CompletedTask;
     }
diff --git a/src/Microsoft.VisualStudio.ProjectSystem.Managed.VS/ProjectSystem/VS/Setup/SetupComponentRegistrationService.cs b/src/Microsoft.VisualStudio.ProjectSystem.Managed.VS/ProjectSystem/VS/Setup/SetupComponentRegistrationService.cs
@@ -204,7 +204,7 @@ private void TryPublish()
         {
             Task task = _missingComponentRegistrationService.RegisterMissingComponentsAsync(missingComponentsByProjectGuid, cancellationToken: default);
 
-            _projectFaultHandlerService.Forget(task, project: null, ProjectFaultSeverity.Recoverable);
+            _projectFaultHandlerService.RegisterFaultHandler(task);
         }
 
         return;
diff --git a/src/Microsoft.VisualStudio.ProjectSystem.Managed.VS/ProjectSystem/VS/UpToDate/UpToDateCheckBuildEventNotifier.cs b/src/Microsoft.VisualStudio.ProjectSystem.Managed.VS/ProjectSystem/VS/UpToDate/UpToDateCheckBuildEventNotifier.cs
@@ -110,7 +110,7 @@ int IVsUpdateSolutionEvents2.UpdateProjectCfg_Done(IVsHierarchy pHierProj, IVsCf
                     }
                 });
 
-                _faultHandlerService.Forget(task.Task, unconfiguredProject);
+                _faultHandlerService.RegisterFaultHandler(task.Task, project: unconfiguredProject);
             }
         }
 
diff --git a/src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/DataflowBlockFactory.cs b/src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/DataflowBlockFactory.cs
@@ -48,6 +48,6 @@ private static void RegisterFaultHandler(IDataflowBlock block, UnconfiguredProje
         Task faultTask = faultHandlerService.RegisterFaultHandlerAsync(block, project, severity);
 
         // We don't actually care about the result of reporting the fault if one occurs
-        faultHandlerService.Forget(faultTask, project);
+        faultHandlerService.RegisterFaultHandler(faultTask, project: project);
     }
 }
diff --git a/src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/Debug/LaunchSettingsProvider.cs b/src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/Debug/LaunchSettingsProvider.cs
@@ -233,9 +233,9 @@ protected override void Initialize()
         // establish the file watcher. We don't need wait this, because files can be changed in the system anyway, so blocking our process
         // doesn't provide real benefit. It is of course possible that the file is changed before the watcher is established. To eliminate this
         // gap, we can recheck file after the watcher is established. I will skip this for now.
-        _project.Services.FaultHandler.Forget(
+        _project.Services.FaultHandler.RegisterFaultHandler(
             _launchSettingFileWatcher.GetValueAsync(),
-            _project,
+            project: _project,
             severity: ProjectFaultSeverity.LimitedFunctionality);
     }
 
@@ -606,9 +606,9 @@ protected override void Dispose(bool disposing)
     {
         if (disposing)
         {
-            _project.Services.FaultHandler.Forget(
+            _project.Services.FaultHandler.RegisterFaultHandler(
                 _launchSettingFileWatcher.DisposeValueAsync(),
-                _project,
+                project: _project,
                 severity: ProjectFaultSeverity.Recoverable);
 
             FileChangeScheduler?.Dispose();
@@ -935,6 +935,6 @@ private async Task<ILaunchSettings> GetSnapshotThrowIfErrorsAsync()
     public void OnFilesChanged(IReadOnlyCollection<(string FilePath, FileWatchChangeKinds FileWatchChangeKinds)> changes)
     {
         _diagnosticOutputService?.WriteLine(string.Join(Environment.NewLine, changes.Select(change => $"File changed: {change.FilePath} ({change.FileWatchChangeKinds})")));
-        _projectFaultHandler.Forget(HandleLaunchSettingsFileChangedAsync(), _project);
+        _projectFaultHandler.RegisterFaultHandler(HandleLaunchSettingsFileChangedAsync(), project: _project);
     }
 }
diff --git a/src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/FaultExtensions.cs b/src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/FaultExtensions.cs
@@ -12,93 +12,6 @@ namespace Microsoft.VisualStudio.ProjectSystem;
 /// </summary>
 internal static class FaultExtensions
 {
-    private static readonly ErrorReportSettings s_defaultReportSettings = new(
-        eventName: "VisualStudioNonFatalErrors2",
-        component: "ManagedProjectSystem",
-        reportType: ErrorReportType.Critical,
-        submitFlags: ErrorReportSubmitFlags.OutOfProcess | ErrorReportSubmitFlags.NoCloseUI,
-        submitUIOptions: ImmutableDictionary.Create<ErrorReportUIType, string>());
-
-    /// <summary>
-    ///     Reports the specified fault.
-    /// </summary>
-    /// <param name="faultHandlerService">
-    ///     The <see cref="IProjectFaultHostHandler"/> that should handle the fault.
-    /// </param>
-    /// <param name="ex">
-    ///     Exception containing the fault information.
-    ///  </param>
-    /// <param name="severity">
-    ///     The severity of the failure.
-    /// </param>
-    /// <param name="project">
-    ///     The project related to the failure, if applicable. Can be <see langword="null"/>.
-    /// </param>
-    public static Task ReportFaultAsync(
-        this IProjectFaultHandlerService faultHandlerService,
-        Exception ex,
-        UnconfiguredProject? project,
-        ProjectFaultSeverity severity = ProjectFaultSeverity.Recoverable)
-    {
-        Requires.NotNull(faultHandlerService);
-
-        return faultHandlerService.HandleFaultAsync(ex, s_defaultReportSettings, severity, project);
-    }
-
-    /// <summary>
-    ///     Attaches error handling to a task so that if it throws an unhandled exception,
-    ///     the error will be reported to the user.
-    /// </summary>
-    /// <param name="faultHandlerService">
-    ///     The <see cref="IProjectFaultHostHandler"/> that should handle the fault.
-    /// </param>
-    /// <param name="task">
-    ///     The task to attach error handling to.
-    /// </param>
-    /// <param name="project">
-    ///     The project related to the failure, if applicable. Can be <see langword="null"/>.
-    /// </param>
-    /// <param name="severity">
-    ///     The severity of the failure.
-    /// </param>
-    public static void Forget(
-        this IProjectFaultHandlerService faultHandlerService,
-        Task task,
-        UnconfiguredProject? project,
-        ProjectFaultSeverity severity = ProjectFaultSeverity.Recoverable)
-    {
-        Requires.NotNull(faultHandlerService);
-
-        faultHandlerService.RegisterFaultHandler(task, s_defaultReportSettings, severity, project);
-    }
-
-    /// <summary>
-    ///     Attaches error handling to a task so that if it throws an unhandled exception,
-    ///     the error will be reported to the user.
-    /// </summary>
-    /// <param name="faultHandlerService">
-    ///     The <see cref="IProjectFaultHostHandler"/> that should handle the fault.
-    /// </param>
-    /// <param name="task">
-    ///     The task to attach error handling to.
-    /// </param>
-    /// <param name="project">
-    ///     The project related to the failure, if applicable. Can be <see langword="null"/>.
-    /// </param>
-    /// <param name="severity">
-    ///     The severity of the failure.
-    /// </param>
-    public static void Forget<TResult>(
-        this IProjectFaultHandlerService faultHandlerService,
-        Task<TResult> task,
-        UnconfiguredProject? project,
-        ProjectFaultSeverity severity = ProjectFaultSeverity.Recoverable)
-    {
-        Requires.NotNull(faultHandlerService);
-
-        faultHandlerService.RegisterFaultHandler(task, s_defaultReportSettings, severity, project);
-    }
-
     /// <summary>
     ///      Executes the specified delegate in a safe fire-and-forget manner, prevent the project from
     ///      closing until it has completed.
@@ -133,7 +46,7 @@ public static void RunAndForget(
             options &= ~ForkOptions.CancelOnUnload;
         }
 
-        threadingService.Fork(asyncAction, factory: null, unconfiguredProject: unconfiguredProject, watsonReportSettings: s_defaultReportSettings, faultSeverity: severity, options: options);
+        threadingService.Fork(asyncAction, factory: null, unconfiguredProject: unconfiguredProject, faultSeverity: severity, options: options);
     }
 
     /// <summary>
@@ -170,7 +83,7 @@ public static void RunAndForget(
             options &= ~ForkOptions.CancelOnUnload;
         }
 
-        threadingService.Fork(asyncAction, factory: null, configuredProject: configuredProject, watsonReportSettings: s_defaultReportSettings, faultSeverity: severity, options: options);
+        threadingService.Fork(asyncAction, factory: null, configuredProject: configuredProject, faultSeverity: severity, options: options);
     }
 
     /// <summary>
@@ -226,7 +139,7 @@ public static Task RegisterFaultHandlerAsync(
                 dataSourceException = ex;
             }
 
-            return faultHandlerService.ReportFaultAsync(dataSourceException, project, severity);
+            return faultHandlerService.HandleFaultAsync(dataSourceException, project: project, severity: severity);
         },
         CancellationToken.None,
         TaskContinuationOptions.OnlyOnFaulted,
@@ -258,6 +171,6 @@ public static void RegisterFaultHandler(
         Task task = RegisterFaultHandlerAsync(faultHandlerService, block, project, severity);
 
         // We don't actually care about the result of reporting the fault if one occurs
-        faultHandlerService.Forget(task, project);
+        faultHandlerService.RegisterFaultHandler(task, project: project);
     }
 }
diff --git a/src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/Tree/Dependencies/DependenciesTreeProvider.cs b/src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/Tree/Dependencies/DependenciesTreeProvider.cs
@@ -138,7 +138,7 @@ async delegate
                 },
                 registerFaultHandler: true);
 
-            UnconfiguredProject.Services.FaultHandler.Forget(task.Task, UnconfiguredProject);
+            UnconfiguredProject.Services.FaultHandler.RegisterFaultHandler(task.Task, project: UnconfiguredProject);
         }
 
         return;
@@ -179,7 +179,7 @@ Task OnDependenciesSnapshotChangedAsync(IProjectVersionedValue<DependenciesSnaps
                     {
                         // We do not expect any exception when we call SubmitTreeUpdateAsync, but we don't want to leak an exception here.
                         // Because it will fault the dataflow block which stops further tree updates.
-                        _ = ProjectFaultHandlerService.ReportFaultAsync(ex, UnconfiguredProject);
+                        _ = ProjectFaultHandlerService.HandleFaultAsync(ex, project: UnconfiguredProject);
                     }
                 },
                 UnconfiguredProjectAsynchronousTasksService.UnloadCancellationToken);

Original file line number	Diff line number	Diff line change
`@@ -168,22 +168,22 @@ public void OnComplete(int hr, uint debugTargetCount, VsDebugTargetProcessInfo[]`
`168`	`168`	`processInfoArray.Length == 1 &&`
`169`	`169`	`vsLaunchedProcess is not null)`
`170`	`170`	`{`
`171`		`- projectFaultHandlerService.Forget(`
	`171`	`+ projectFaultHandlerService.RegisterFaultHandler(`
`172`	`172`	`targetsProvider5.OnAfterLaunchAsync(launchOptions, activeProfile, debugLaunchSettings[0], vsLaunchedProcess, processInfoArray[0]),`
`173`		`- unconfiguredProject);`
	`173`	`+ project: unconfiguredProject);`
`174`	`174`	`}`
`175`	`175`	`else`
`176`	`176`	`{`
`177`		`- projectFaultHandlerService.Forget(`
	`177`	`+ projectFaultHandlerService.RegisterFaultHandler(`
`178`	`178`	`targetsProvider4.OnAfterLaunchAsync(launchOptions, activeProfile, processInfoArray),`
`179`		`- unconfiguredProject);`
	`179`	`+ project: unconfiguredProject);`
`180`	`180`	`}`
`181`	`181`	`}`
`182`	`182`	`else if (targetsProvider is not null)`
`183`	`183`	`{`
`184`		`- projectFaultHandlerService.Forget(`
	`184`	`+ projectFaultHandlerService.RegisterFaultHandler(`
`185`	`185`	`targetsProvider.OnAfterLaunchAsync(launchOptions, activeProfile),`
`186`		`- unconfiguredProject);`
	`186`	`+ project: unconfiguredProject);`
`187`	`187`	`}`
`188`	`188`	`}`
`189`	`189`
Original file line number	Diff line number	Diff line change
`@@ -162,7 +162,7 @@ protected override async Task InitializeCoreAsync(CancellationToken cancellation`
`162`	`162`	`_firstPrimaryWorkspaceSet.TrySetException(ex);`
`163`	`163`
`164`	`164`	`// Report the exception as an NFE that limits the functionality of the project.`
`165`		`- _ = _projectFaultHandler.ReportFaultAsync(ex, _unconfiguredProject, ProjectFaultSeverity.LimitedFunctionality);`
	`165`	`+ _ = _projectFaultHandler.HandleFaultAsync(ex, project: _unconfiguredProject, severity: ProjectFaultSeverity.LimitedFunctionality);`
`166`	`166`	`},`
`167`	`167`	`CancellationToken.None,`
`168`	`168`	`TaskContinuationOptions.OnlyOnFaulted,`
`@@ -360,7 +360,7 @@ public async Task AfterLoadInitialConfigurationAsync()`
`360`	`360`
`361`	`361`	`// While we want make sure it's loaded before PrioritizedProjectLoadedInHost,`
`362`	`362`	`// we don't want to block project factory completion on its load, so fire and forget.`
`363`		`- _projectFaultHandler.Forget(result, _unconfiguredProject, ProjectFaultSeverity.LimitedFunctionality);`
	`363`	`+ _projectFaultHandler.RegisterFaultHandler(result, project: _unconfiguredProject, severity: ProjectFaultSeverity.LimitedFunctionality);`
`364`	`364`	`}`
`365`	`365`	`}`
`366`	`366`
Original file line number	Diff line number	Diff line change
`@@ -304,7 +304,7 @@ async Task ProcessInitialEvaluationDataAsync(CancellationToken cancellationToken`
`304`	`304`	`{`
`305`	`305`	`_state = WorkspaceState.Failed;`
`306`	`306`
`307`		`- await _faultHandlerService.ReportFaultAsync(ex, _unconfiguredProject, ProjectFaultSeverity.LimitedFunctionality);`
	`307`	`+ await _faultHandlerService.HandleFaultAsync(ex, project: _unconfiguredProject, severity: ProjectFaultSeverity.LimitedFunctionality);`
`308`	`308`
`309`	`309`	`_context?.Dispose();`
`310`	`310`
Original file line number	Diff line number	Diff line change
`@@ -232,6 +232,6 @@ private void RegisterProjectRestoreInfoSource()`
`232`	`232`	`});`
`233`	`233`	`#pragma warning restore RS0030 // Do not used banned APIs`
`234`	`234`
`235`		`- _faultHandlerService.Forget(registerRestoreInfoSourceTask, _project, ProjectFaultSeverity.Recoverable);`
	`235`	`+ _faultHandlerService.RegisterFaultHandler(registerRestoreInfoSourceTask, project: _project);`
`236`	`236`	`}`
`237`	`237`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ public Task LoadAsync()`
`57`	`57`	`// Don't block on initialization here. It doesn't need to complete before we continue here,`
`58`	`58`	`// and initialization will wait on some features of the project to become available, which would`
`59`	`59`	`// cause a deadlock if we waited here. We file this so any exception is reported as an NFE.`
`60`		`- _projectFaultHandlerService.Forget(task, _unconfiguredProject, ProjectFaultSeverity.LimitedFunctionality);`
	`60`	`+ _projectFaultHandlerService.RegisterFaultHandler(task, project: _unconfiguredProject, severity: ProjectFaultSeverity.LimitedFunctionality);`
`61`	`61`
`62`	`62`	`return Task.CompletedTask;`
`63`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -204,7 +204,7 @@ private void TryPublish()`
`204`	`204`	`{`
`205`	`205`	`Task task = _missingComponentRegistrationService.RegisterMissingComponentsAsync(missingComponentsByProjectGuid, cancellationToken: default);`
`206`	`206`
`207`		`- _projectFaultHandlerService.Forget(task, project: null, ProjectFaultSeverity.Recoverable);`
	`207`	`+ _projectFaultHandlerService.RegisterFaultHandler(task);`
`208`	`208`	`}`
`209`	`209`
`210`	`210`	`return;`
Original file line number	Diff line number	Diff line change
`@@ -110,7 +110,7 @@ int IVsUpdateSolutionEvents2.UpdateProjectCfg_Done(IVsHierarchy pHierProj, IVsCf`
`110`	`110`	`}`
`111`	`111`	`});`
`112`	`112`
`113`		`- _faultHandlerService.Forget(task.Task, unconfiguredProject);`
	`113`	`+ _faultHandlerService.RegisterFaultHandler(task.Task, project: unconfiguredProject);`
`114`	`114`	`}`
`115`	`115`	`}`
`116`	`116`
Original file line number	Diff line number	Diff line change
`@@ -48,6 +48,6 @@ private static void RegisterFaultHandler(IDataflowBlock block, UnconfiguredProje`
`48`	`48`	`Task faultTask = faultHandlerService.RegisterFaultHandlerAsync(block, project, severity);`
`49`	`49`
`50`	`50`	`// We don't actually care about the result of reporting the fault if one occurs`
`51`		`- faultHandlerService.Forget(faultTask, project);`
	`51`	`+ faultHandlerService.RegisterFaultHandler(faultTask, project: project);`
`52`	`52`	`}`
`53`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -233,9 +233,9 @@ protected override void Initialize()`
`233`	`233`	`// establish the file watcher. We don't need wait this, because files can be changed in the system anyway, so blocking our process`
`234`	`234`	`// doesn't provide real benefit. It is of course possible that the file is changed before the watcher is established. To eliminate this`
`235`	`235`	`// gap, we can recheck file after the watcher is established. I will skip this for now.`
`236`		`- _project.Services.FaultHandler.Forget(`
	`236`	`+ _project.Services.FaultHandler.RegisterFaultHandler(`
`237`	`237`	`_launchSettingFileWatcher.GetValueAsync(),`
`238`		`- _project,`
	`238`	`+ project: _project,`
`239`	`239`	`severity: ProjectFaultSeverity.LimitedFunctionality);`
`240`	`240`	`}`
`241`	`241`
`@@ -606,9 +606,9 @@ protected override void Dispose(bool disposing)`
`606`	`606`	`{`
`607`	`607`	`if (disposing)`
`608`	`608`	`{`
`609`		`- _project.Services.FaultHandler.Forget(`
	`609`	`+ _project.Services.FaultHandler.RegisterFaultHandler(`
`610`	`610`	`_launchSettingFileWatcher.DisposeValueAsync(),`
`611`		`- _project,`
	`611`	`+ project: _project,`
`612`	`612`	`severity: ProjectFaultSeverity.Recoverable);`
`613`	`613`
`614`	`614`	`FileChangeScheduler?.Dispose();`
`@@ -935,6 +935,6 @@ private async Task<ILaunchSettings> GetSnapshotThrowIfErrorsAsync()`
`935`	`935`	`public void OnFilesChanged(IReadOnlyCollection<(string FilePath, FileWatchChangeKinds FileWatchChangeKinds)> changes)`
`936`	`936`	`{`
`937`	`937`	`_diagnosticOutputService?.WriteLine(string.Join(Environment.NewLine, changes.Select(change => $"File changed: {change.FilePath} ({change.FileWatchChangeKinds})")));`
`938`		`- _projectFaultHandler.Forget(HandleLaunchSettingsFileChangedAsync(), _project);`
	`938`	`+ _projectFaultHandler.RegisterFaultHandler(HandleLaunchSettingsFileChangedAsync(), project: _project);`
`939`	`939`	`}`
`940`	`940`	`}`