Fix typos & some nullable metadata in the code.

Author: Lifeng Lu

src/Microsoft.VisualStudio.Threading/JoinableTask.cs

@@ -381,8 +381,8 @@ internal WeakReference<JoinableTask> WeakSelf
         }
 
         /// <summary>
-        /// Gets or sets potential unreacable dependent nodes.
-        /// This is a special collection only used in sychronized task when there are other tasks which are marked to block it through ref-count code.
+        /// Gets or sets potential unreachable dependent nodes.
+        /// This is a special collection only used in synchronized task when there are other tasks which are marked to block it through ref-count code.
         /// However, it is possible the reference count is retained by loop-dependencies. This collection tracking those items,
         /// so the clean-up logic can run when it becomes necessary.
         /// </summary>
@@ -717,7 +717,7 @@ internal void Post(SendOrPostCallback d, object? state, bool mainThreadAffinitiz
                                         // because dependencies may change, and invalidate this work. However, we try to do this work in the background thread to make it less likely
                                         // doing the expensive work on the UI thread.
                                         if (JoinableTaskDependencyGraph.CleanUpPotentialUnreachableDependentItems(taskToNotify, out HashSet<IJoinableTaskDependent>? reachableNodes) &&
-                                            !reachableNodes!.Contains(this))
+                                            !reachableNodes.Contains(this))
                                         {
                                             continue;
                                         }
@@ -1128,7 +1128,7 @@ private bool TryDequeueSelfOrDependencies(bool onMainThread, ref HashSet<IJoinab
                             visited.Clear();
                         }
 
-                        var foundWork = TryDequeueSelfOrDependencies(this, onMainThread, visited, out work);
+                        bool foundWork = TryDequeueSelfOrDependencies(this, onMainThread, visited, out work);
 
                         HashSet<IJoinableTaskDependent>? visitedNodes = visited;
                         if (visitedNodes != null && this.PotentialUnreachableDependents != null)

src/Microsoft.VisualStudio.Threading/JoinableTaskDependencyGraph.cs

@@ -226,7 +226,7 @@ internal static HashSet<JoinableTask> GetDependentTasksFromCandidates(IEnumerabl
         /// <param name="syncTask">A thread blocking sychornizing task.</param>
         /// <param name="allReachableNodes">Returns all reachable nodes in the connected dependency graph, if unreachable dependency is found.</param>
         /// <returns>True if it removes any unreachable items.</returns>
-        internal static bool CleanUpPotentialUnreachableDependentItems(JoinableTask syncTask, [MaybeNullWhen(false)] out HashSet<IJoinableTaskDependent>? allReachableNodes)
+        internal static bool CleanUpPotentialUnreachableDependentItems(JoinableTask syncTask, [NotNullWhen(true)] out HashSet<IJoinableTaskDependent>? allReachableNodes)
         {
             Requires.NotNull(syncTask, nameof(syncTask));
 
@@ -254,11 +254,8 @@ internal static bool CleanUpPotentialUnreachableDependentItems(JoinableTask sync
                     return true;
                 }
             }
-            else
-            {
-                allReachableNodes = null;
-            }
 
+            allReachableNodes = null;
             return false;
         }
 
@@ -607,7 +604,7 @@ internal bool HasMainThreadSynchronousTaskWaiting(IJoinableTaskDependent taskIte
                         {
                             // This might remove the current tracking item from the linked list, so we capture next node first.
                             if (!CleanUpPotentialUnreachableDependentItems(existingTaskTracking.SynchronousTask, out HashSet<IJoinableTaskDependent>? allReachableNodes) ||
-                                allReachableNodes!.Contains(taskItem))
+                                allReachableNodes.Contains(taskItem))
                             {
                                 // this task is still a dependenting task
                                 return true;
@@ -877,7 +874,9 @@ private static void RemoveDependingSynchronousTaskFrom(IReadOnlyList<IJoinableTa
                 {
                     if (force)
                     {
-                        Assumes.True(reachableNodes!.Count == 0);
+                        Assumes.NotNull(reachableNodes);
+                        Assumes.True(reachableNodes.Count == 0);
+
                         RemoveUnreachableDependentItems(syncTask, remainNodes, reachableNodes);
 
                         syncTask.PotentialUnreachableDependents = null;