Merge pull request #73019 from CyrusNajmabadi/argStyle

CyrusNajmabadi · web-flow · commit cfa8c1e16a1b · 2024-04-14T14:25:40.000-07:00
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/ChecksumCollection.cs b/src/Workspaces/Core/Portable/Workspace/Solution/ChecksumCollection.cs
@@ -54,11 +54,12 @@ public void AddAllTo(HashSet<Checksum> checksums)
     }
 
     [PerformanceSensitive("https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1333566", AllowGenericEnumeration = false)]
-    internal static async Task FindAsync<TState>(
+    internal static async Task FindAsync<TState, TArg>(
         AssetPath assetPath,
         TextDocumentStates<TState> documentStates,
         HashSet<Checksum> searchingChecksumsLeft,
-        Action<Checksum, object> onAssetFound,
+        Action<Checksum, object, TArg> onAssetFound,
+        TArg arg,
         CancellationToken cancellationToken) where TState : TextDocumentState
     {
         var hintDocument = assetPath.DocumentId;
@@ -68,7 +69,7 @@ internal static async Task FindAsync<TState>(
             if (state != null)
             {
                 Contract.ThrowIfFalse(state.TryGetStateChecksums(out var stateChecksums));
-                await stateChecksums.FindAsync(assetPath, state, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);
+                await stateChecksums.FindAsync(assetPath, state, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
             }
         }
         else
@@ -81,16 +82,17 @@ internal static async Task FindAsync<TState>(
 
                 Contract.ThrowIfFalse(state.TryGetStateChecksums(out var stateChecksums));
 
-                await stateChecksums.FindAsync(assetPath, state, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);
+                await stateChecksums.FindAsync(assetPath, state, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
             }
         }
     }
 
-    internal static void Find<T>(
+    internal static void Find<T, TArg>(
         IReadOnlyList<T> values,
         ChecksumCollection checksums,
         HashSet<Checksum> searchingChecksumsLeft,
-        Action<Checksum, object> onAssetFound,
+        Action<Checksum, object, TArg> onAssetFound,
+        TArg arg,
         CancellationToken cancellationToken) where T : class
     {
         Contract.ThrowIfFalse(values.Count == checksums.Children.Length);
@@ -103,7 +105,7 @@ internal static void Find<T>(
 
             var checksum = checksums.Children[i];
             if (searchingChecksumsLeft.Remove(checksum))
-                onAssetFound(checksum, values[i]);
+                onAssetFound(checksum, values[i], arg);
         }
     }
 
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/StateChecksums.cs b/src/Workspaces/Core/Portable/Workspace/Solution/StateChecksums.cs
@@ -113,12 +113,13 @@ public static SolutionCompilationStateChecksums Deserialize(ObjectReader reader)
         return result;
     }
 
-    public async Task FindAsync(
+    public async Task FindAsync<TArg>(
         SolutionCompilationState compilationState,
         ProjectCone? projectCone,
         AssetPath assetPath,
         HashSet<Checksum> searchingChecksumsLeft,
-        Action<Checksum, object> onAssetFound,
+        Action<Checksum, object, TArg> onAssetFound,
+        TArg arg,
         CancellationToken cancellationToken)
     {
         cancellationToken.ThrowIfCancellationRequested();
@@ -128,10 +129,10 @@ public async Task FindAsync(
         if (assetPath.IncludeSolutionCompilationState)
         {
             if (assetPath.IncludeSolutionCompilationStateChecksums && searchingChecksumsLeft.Remove(this.Checksum))
-                onAssetFound(this.Checksum, this);
+                onAssetFound(this.Checksum, this, arg);
 
             if (assetPath.IncludeSolutionSourceGeneratorExecutionVersionMap && searchingChecksumsLeft.Remove(this.SourceGeneratorExecutionVersionMap))
-                onAssetFound(this.SourceGeneratorExecutionVersionMap, compilationState.SourceGeneratorExecutionVersionMap);
+                onAssetFound(this.SourceGeneratorExecutionVersionMap, compilationState.SourceGeneratorExecutionVersionMap, arg);
 
             if (compilationState.FrozenSourceGeneratedDocumentStates != null)
             {
@@ -143,7 +144,7 @@ public async Task FindAsync(
                 {
                     await ChecksumCollection.FindAsync(
                         new AssetPath(AssetPathKind.DocumentText, assetPath.ProjectId, assetPath.DocumentId),
-                        compilationState.FrozenSourceGeneratedDocumentStates, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);
+                        compilationState.FrozenSourceGeneratedDocumentStates, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
                 }
 
                 // ... or one of the identities. In this case, we'll use the fact that there's a 1:1 correspondence between the
@@ -161,7 +162,7 @@ await ChecksumCollection.FindAsync(
                             if (searchingChecksumsLeft.Remove(identityChecksum))
                             {
                                 Contract.ThrowIfFalse(compilationState.FrozenSourceGeneratedDocumentStates.TryGetState(documentId, out var state));
-                                onAssetFound(identityChecksum, state.Identity);
+                                onAssetFound(identityChecksum, state.Identity, arg);
                             }
                         }
                     }
@@ -175,7 +176,7 @@ await ChecksumCollection.FindAsync(
                             {
                                 var id = FrozenSourceGeneratedDocuments.Value.Ids[i];
                                 Contract.ThrowIfFalse(compilationState.FrozenSourceGeneratedDocumentStates.TryGetState(id, out var state));
-                                onAssetFound(identityChecksum, state.Identity);
+                                onAssetFound(identityChecksum, state.Identity, arg);
                             }
                         }
                     }
@@ -189,13 +190,13 @@ await ChecksumCollection.FindAsync(
             // If we're not in a project cone, start the search at the top most state-checksum corresponding to the
             // entire solution.
             Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(out var solutionChecksums));
-            await solutionChecksums.FindAsync(solutionState, projectCone, assetPath, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);
+            await solutionChecksums.FindAsync(solutionState, projectCone, assetPath, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
         }
         else
         {
             // Otherwise, grab the top-most state checksum for this cone and search within that.
             Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(projectCone.RootProjectId, out var solutionChecksums));
-            await solutionChecksums.FindAsync(solutionState, projectCone, assetPath, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);
+            await solutionChecksums.FindAsync(solutionState, projectCone, assetPath, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
         }
     }
 }
@@ -264,12 +265,13 @@ public static SolutionStateChecksums Deserialize(ObjectReader reader)
         return result;
     }
 
-    public async Task FindAsync(
+    public async Task FindAsync<TArg>(
         SolutionState solution,
         ProjectCone? projectCone,
         AssetPath assetPath,
         HashSet<Checksum> searchingChecksumsLeft,
-        Action<Checksum, object> onAssetFound,
+        Action<Checksum, object, TArg> onAssetFound,
+        TArg arg,
         CancellationToken cancellationToken)
     {
         cancellationToken.ThrowIfCancellationRequested();
@@ -279,13 +281,13 @@ public async Task FindAsync(
         if (assetPath.IncludeSolutionState)
         {
             if (assetPath.IncludeSolutionStateChecksums && searchingChecksumsLeft.Remove(Checksum))
-                onAssetFound(Checksum, this);
+                onAssetFound(Checksum, this, arg);
 
             if (assetPath.IncludeSolutionAttributes && searchingChecksumsLeft.Remove(Attributes))
-                onAssetFound(Attributes, solution.SolutionAttributes);
+                onAssetFound(Attributes, solution.SolutionAttributes, arg);
 
             if (assetPath.IncludeSolutionAnalyzerReferences)
-                ChecksumCollection.Find(solution.AnalyzerReferences, AnalyzerReferences, searchingChecksumsLeft, onAssetFound, cancellationToken);
+                ChecksumCollection.Find(solution.AnalyzerReferences, AnalyzerReferences, searchingChecksumsLeft, onAssetFound, arg, cancellationToken);
         }
 
         if (searchingChecksumsLeft.Count == 0)
@@ -304,7 +306,7 @@ public async Task FindAsync(
                 if (projectState != null &&
                     projectState.TryGetStateChecksums(out var projectStateChecksums))
                 {
-                    await projectStateChecksums.FindAsync(projectState, assetPath, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);
+                    await projectStateChecksums.FindAsync(projectState, assetPath, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
                 }
             }
             else
@@ -327,7 +329,7 @@ public async Task FindAsync(
                     if (!projectState.TryGetStateChecksums(out var projectStateChecksums))
                         continue;
 
-                    await projectStateChecksums.FindAsync(projectState, assetPath, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);
+                    await projectStateChecksums.FindAsync(projectState, assetPath, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
                 }
             }
         }
@@ -431,11 +433,12 @@ public static ProjectStateChecksums Deserialize(ObjectReader reader)
         return result;
     }
 
-    public async Task FindAsync(
+    public async Task FindAsync<TArg>(
         ProjectState state,
         AssetPath assetPath,
         HashSet<Checksum> searchingChecksumsLeft,
-        Action<Checksum, object> onAssetFound,
+        Action<Checksum, object, TArg> onAssetFound,
+        TArg arg,
         CancellationToken cancellationToken)
     {
         cancellationToken.ThrowIfCancellationRequested();
@@ -449,38 +452,38 @@ public async Task FindAsync(
         if (assetPath.IncludeProjects)
         {
             if (assetPath.IncludeProjectStateChecksums && searchingChecksumsLeft.Remove(Checksum))
-                onAssetFound(Checksum, this);
+                onAssetFound(Checksum, this, arg);
 
             if (assetPath.IncludeProjectAttributes && searchingChecksumsLeft.Remove(Info))
-                onAssetFound(Info, state.ProjectInfo.Attributes);
+                onAssetFound(Info, state.ProjectInfo.Attributes, arg);
 
             if (assetPath.IncludeProjectCompilationOptions && searchingChecksumsLeft.Remove(CompilationOptions))
             {
                 var compilationOptions = state.CompilationOptions ?? throw new InvalidOperationException("We should not be trying to serialize a project with no compilation options; RemoteSupportedLanguages.IsSupported should have filtered it out.");
-                onAssetFound(CompilationOptions, compilationOptions);
+                onAssetFound(CompilationOptions, compilationOptions, arg);
             }
 
             if (assetPath.IncludeProjectParseOptions && searchingChecksumsLeft.Remove(ParseOptions))
             {
                 var parseOptions = state.ParseOptions ?? throw new InvalidOperationException("We should not be trying to serialize a project with no parse options; RemoteSupportedLanguages.IsSupported should have filtered it out.");
-                onAssetFound(ParseOptions, parseOptions);
+                onAssetFound(ParseOptions, parseOptions, arg);
             }
 
             if (assetPath.IncludeProjectProjectReferences)
-                ChecksumCollection.Find(state.ProjectReferences, ProjectReferences, searchingChecksumsLeft, onAssetFound, cancellationToken);
+                ChecksumCollection.Find(state.ProjectReferences, ProjectReferences, searchingChecksumsLeft, onAssetFound, arg, cancellationToken);
 
             if (assetPath.IncludeProjectMetadataReferences)
-                ChecksumCollection.Find(state.MetadataReferences, MetadataReferences, searchingChecksumsLeft, onAssetFound, cancellationToken);
+                ChecksumCollection.Find(state.MetadataReferences, MetadataReferences, searchingChecksumsLeft, onAssetFound, arg, cancellationToken);
 
             if (assetPath.IncludeProjectAnalyzerReferences)
-                ChecksumCollection.Find(state.AnalyzerReferences, AnalyzerReferences, searchingChecksumsLeft, onAssetFound, cancellationToken);
+                ChecksumCollection.Find(state.AnalyzerReferences, AnalyzerReferences, searchingChecksumsLeft, onAssetFound, arg, cancellationToken);
         }
 
         if (assetPath.IncludeDocuments)
         {
-            await ChecksumCollection.FindAsync(assetPath, state.DocumentStates, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);
-            await ChecksumCollection.FindAsync(assetPath, state.AdditionalDocumentStates, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);
-            await ChecksumCollection.FindAsync(assetPath, state.AnalyzerConfigDocumentStates, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);
+            await ChecksumCollection.FindAsync(assetPath, state.DocumentStates, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
+            await ChecksumCollection.FindAsync(assetPath, state.AdditionalDocumentStates, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
+            await ChecksumCollection.FindAsync(assetPath, state.AnalyzerConfigDocumentStates, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
         }
     }
 }
@@ -502,24 +505,25 @@ public void AddAllTo(HashSet<Checksum> checksums)
         checksums.AddIfNotNullChecksum(this.Text);
     }
 
-    public async Task FindAsync(
+    public async Task FindAsync<TArg>(
         AssetPath assetPath,
         TextDocumentState state,
         HashSet<Checksum> searchingChecksumsLeft,
-        Action<Checksum, object> onAssetFound,
+        Action<Checksum, object, TArg> onAssetFound,
+        TArg arg,
         CancellationToken cancellationToken)
     {
         Debug.Assert(state.TryGetStateChecksums(out var stateChecksum) && this == stateChecksum);
 
         cancellationToken.ThrowIfCancellationRequested();
 
         if (assetPath.IncludeDocumentAttributes && searchingChecksumsLeft.Remove(Info))
-            onAssetFound(Info, state.Attributes);
+            onAssetFound(Info, state.Attributes, arg);
 
         if (assetPath.IncludeDocumentText && searchingChecksumsLeft.Remove(Text))
         {
             var text = await SerializableSourceText.FromTextDocumentStateAsync(state, cancellationToken).ConfigureAwait(false);
-            onAssetFound(Text, text);
+            onAssetFound(Text, text, arg);
         }
     }
 }
diff --git a/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs b/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
@@ -60,15 +60,16 @@ public async Task AddAssetsAsync(
 
             await FindAssetsAsync(
                 assetPath, checksumsToFind,
-                (checksum, asset) => assetMap[checksum] = asset,
+                static (checksum, asset, assetMap) => assetMap[checksum] = asset,
+                assetMap,
                 cancellationToken).ConfigureAwait(false);
 
             Contract.ThrowIfTrue(checksumsToFind.Count > 0);
             Contract.ThrowIfTrue(assetMap.Count != numberOfChecksumsToSearch);
         }
 
-        private async Task FindAssetsAsync(
-            AssetPath assetPath, HashSet<Checksum> remainingChecksumsToFind, Action<Checksum, object> onAssetFound, CancellationToken cancellationToken)
+        private async Task FindAssetsAsync<TArg>(
+            AssetPath assetPath, HashSet<Checksum> remainingChecksumsToFind, Action<Checksum, object, TArg> onAssetFound, TArg arg, CancellationToken cancellationToken)
         {
             var solutionState = this.CompilationState;
 
@@ -77,13 +78,13 @@ private async Task FindAssetsAsync(
                 // If we're not in a project cone, start the search at the top most state-checksum corresponding to the
                 // entire solution.
                 Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(out var stateChecksums));
-                await stateChecksums.FindAsync(solutionState, this.ProjectCone, assetPath, remainingChecksumsToFind, onAssetFound, cancellationToken).ConfigureAwait(false);
+                await stateChecksums.FindAsync(solutionState, this.ProjectCone, assetPath, remainingChecksumsToFind, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
             }
             else
             {
                 // Otherwise, grab the top-most state checksum for this cone and search within that.
                 Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(this.ProjectCone.RootProjectId, out var stateChecksums));
-                await stateChecksums.FindAsync(solutionState, this.ProjectCone, assetPath, remainingChecksumsToFind, onAssetFound, cancellationToken).ConfigureAwait(false);
+                await stateChecksums.FindAsync(solutionState, this.ProjectCone, assetPath, remainingChecksumsToFind, onAssetFound, arg, cancellationToken).ConfigureAwait(false);
             }
         }
 
diff --git a/src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs b/src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs

Original file line number	Diff line number	Diff line change
`@@ -54,11 +54,12 @@ public void AddAllTo(HashSet<Checksum> checksums)`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`[PerformanceSensitive("https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1333566", AllowGenericEnumeration = false)]`
`57`		`- internal static async Task FindAsync<TState>(`
	`57`	`+ internal static async Task FindAsync<TState, TArg>(`
`58`	`58`	`AssetPath assetPath,`
`59`	`59`	`TextDocumentStates<TState> documentStates,`
`60`	`60`	`HashSet<Checksum> searchingChecksumsLeft,`
`61`		`- Action<Checksum, object> onAssetFound,`
	`61`	`+ Action<Checksum, object, TArg> onAssetFound,`
	`62`	`+ TArg arg,`
`62`	`63`	`CancellationToken cancellationToken) where TState : TextDocumentState`
`63`	`64`	`{`
`64`	`65`	`var hintDocument = assetPath.DocumentId;`
`@@ -68,7 +69,7 @@ internal static async Task FindAsync<TState>(`
`68`	`69`	`if (state != null)`
`69`	`70`	`{`
`70`	`71`	`Contract.ThrowIfFalse(state.TryGetStateChecksums(out var stateChecksums));`
`71`		`- await stateChecksums.FindAsync(assetPath, state, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);`
	`72`	`+ await stateChecksums.FindAsync(assetPath, state, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);`
`72`	`73`	`}`
`73`	`74`	`}`
`74`	`75`	`else`
`@@ -81,16 +82,17 @@ internal static async Task FindAsync<TState>(`
`81`	`82`
`82`	`83`	`Contract.ThrowIfFalse(state.TryGetStateChecksums(out var stateChecksums));`
`83`	`84`
`84`		`- await stateChecksums.FindAsync(assetPath, state, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);`
	`85`	`+ await stateChecksums.FindAsync(assetPath, state, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);`
`85`	`86`	`}`
`86`	`87`	`}`
`87`	`88`	`}`
`88`	`89`
`89`		`- internal static void Find<T>(`
	`90`	`+ internal static void Find<T, TArg>(`
`90`	`91`	`IReadOnlyList<T> values,`
`91`	`92`	`ChecksumCollection checksums,`
`92`	`93`	`HashSet<Checksum> searchingChecksumsLeft,`
`93`		`- Action<Checksum, object> onAssetFound,`
	`94`	`+ Action<Checksum, object, TArg> onAssetFound,`
	`95`	`+ TArg arg,`
`94`	`96`	`CancellationToken cancellationToken) where T : class`
`95`	`97`	`{`
`96`	`98`	`Contract.ThrowIfFalse(values.Count == checksums.Children.Length);`
`@@ -103,7 +105,7 @@ internal static void Find<T>(`
`103`	`105`
`104`	`106`	`var checksum = checksums.Children[i];`
`105`	`107`	`if (searchingChecksumsLeft.Remove(checksum))`
`106`		`- onAssetFound(checksum, values[i]);`
	`108`	`+ onAssetFound(checksum, values[i], arg);`
`107`	`109`	`}`
`108`	`110`	`}`
`109`	`111`
Original file line number	Diff line number	Diff line change
`@@ -113,12 +113,13 @@ public static SolutionCompilationStateChecksums Deserialize(ObjectReader reader)`
`113`	`113`	`return result;`
`114`	`114`	`}`
`115`	`115`
`116`		`- public async Task FindAsync(`
	`116`	`+ public async Task FindAsync<TArg>(`
`117`	`117`	`SolutionCompilationState compilationState,`
`118`	`118`	`ProjectCone? projectCone,`
`119`	`119`	`AssetPath assetPath,`
`120`	`120`	`HashSet<Checksum> searchingChecksumsLeft,`
`121`		`- Action<Checksum, object> onAssetFound,`
	`121`	`+ Action<Checksum, object, TArg> onAssetFound,`
	`122`	`+ TArg arg,`
`122`	`123`	`CancellationToken cancellationToken)`
`123`	`124`	`{`
`124`	`125`	`cancellationToken.ThrowIfCancellationRequested();`
`@@ -128,10 +129,10 @@ public async Task FindAsync(`
`128`	`129`	`if (assetPath.IncludeSolutionCompilationState)`
`129`	`130`	`{`
`130`	`131`	`if (assetPath.IncludeSolutionCompilationStateChecksums && searchingChecksumsLeft.Remove(this.Checksum))`
`131`		`- onAssetFound(this.Checksum, this);`
	`132`	`+ onAssetFound(this.Checksum, this, arg);`
`132`	`133`
`133`	`134`	`if (assetPath.IncludeSolutionSourceGeneratorExecutionVersionMap && searchingChecksumsLeft.Remove(this.SourceGeneratorExecutionVersionMap))`
`134`		`- onAssetFound(this.SourceGeneratorExecutionVersionMap, compilationState.SourceGeneratorExecutionVersionMap);`
	`135`	`+ onAssetFound(this.SourceGeneratorExecutionVersionMap, compilationState.SourceGeneratorExecutionVersionMap, arg);`
`135`	`136`
`136`	`137`	`if (compilationState.FrozenSourceGeneratedDocumentStates != null)`
`137`	`138`	`{`
`@@ -143,7 +144,7 @@ public async Task FindAsync(`
`143`	`144`	`{`
`144`	`145`	`await ChecksumCollection.FindAsync(`
`145`	`146`	`new AssetPath(AssetPathKind.DocumentText, assetPath.ProjectId, assetPath.DocumentId),`
`146`		`- compilationState.FrozenSourceGeneratedDocumentStates, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);`
	`147`	`+ compilationState.FrozenSourceGeneratedDocumentStates, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);`
`147`	`148`	`}`
`148`	`149`
`149`	`150`	`// ... or one of the identities. In this case, we'll use the fact that there's a 1:1 correspondence between the`
`@@ -161,7 +162,7 @@ await ChecksumCollection.FindAsync(`
`161`	`162`	`if (searchingChecksumsLeft.Remove(identityChecksum))`
`162`	`163`	`{`
`163`	`164`	`Contract.ThrowIfFalse(compilationState.FrozenSourceGeneratedDocumentStates.TryGetState(documentId, out var state));`
`164`		`- onAssetFound(identityChecksum, state.Identity);`
	`165`	`+ onAssetFound(identityChecksum, state.Identity, arg);`
`165`	`166`	`}`
`166`	`167`	`}`
`167`	`168`	`}`
`@@ -175,7 +176,7 @@ await ChecksumCollection.FindAsync(`
`175`	`176`	`{`
`176`	`177`	`var id = FrozenSourceGeneratedDocuments.Value.Ids[i];`
`177`	`178`	`Contract.ThrowIfFalse(compilationState.FrozenSourceGeneratedDocumentStates.TryGetState(id, out var state));`
`178`		`- onAssetFound(identityChecksum, state.Identity);`
	`179`	`+ onAssetFound(identityChecksum, state.Identity, arg);`
`179`	`180`	`}`
`180`	`181`	`}`
`181`	`182`	`}`
`@@ -189,13 +190,13 @@ await ChecksumCollection.FindAsync(`
`189`	`190`	`// If we're not in a project cone, start the search at the top most state-checksum corresponding to the`
`190`	`191`	`// entire solution.`
`191`	`192`	`Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(out var solutionChecksums));`
`192`		`- await solutionChecksums.FindAsync(solutionState, projectCone, assetPath, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);`
	`193`	`+ await solutionChecksums.FindAsync(solutionState, projectCone, assetPath, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);`
`193`	`194`	`}`
`194`	`195`	`else`
`195`	`196`	`{`
`196`	`197`	`// Otherwise, grab the top-most state checksum for this cone and search within that.`
`197`	`198`	`Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(projectCone.RootProjectId, out var solutionChecksums));`
`198`		`- await solutionChecksums.FindAsync(solutionState, projectCone, assetPath, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);`
	`199`	`+ await solutionChecksums.FindAsync(solutionState, projectCone, assetPath, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);`
`199`	`200`	`}`
`200`	`201`	`}`
`201`	`202`	`}`
`@@ -264,12 +265,13 @@ public static SolutionStateChecksums Deserialize(ObjectReader reader)`
`264`	`265`	`return result;`
`265`	`266`	`}`
`266`	`267`
`267`		`- public async Task FindAsync(`
	`268`	`+ public async Task FindAsync<TArg>(`
`268`	`269`	`SolutionState solution,`
`269`	`270`	`ProjectCone? projectCone,`
`270`	`271`	`AssetPath assetPath,`
`271`	`272`	`HashSet<Checksum> searchingChecksumsLeft,`
`272`		`- Action<Checksum, object> onAssetFound,`
	`273`	`+ Action<Checksum, object, TArg> onAssetFound,`
	`274`	`+ TArg arg,`
`273`	`275`	`CancellationToken cancellationToken)`
`274`	`276`	`{`
`275`	`277`	`cancellationToken.ThrowIfCancellationRequested();`
`@@ -279,13 +281,13 @@ public async Task FindAsync(`
`279`	`281`	`if (assetPath.IncludeSolutionState)`
`280`	`282`	`{`
`281`	`283`	`if (assetPath.IncludeSolutionStateChecksums && searchingChecksumsLeft.Remove(Checksum))`
`282`		`- onAssetFound(Checksum, this);`
	`284`	`+ onAssetFound(Checksum, this, arg);`
`283`	`285`
`284`	`286`	`if (assetPath.IncludeSolutionAttributes && searchingChecksumsLeft.Remove(Attributes))`
`285`		`- onAssetFound(Attributes, solution.SolutionAttributes);`
	`287`	`+ onAssetFound(Attributes, solution.SolutionAttributes, arg);`
`286`	`288`
`287`	`289`	`if (assetPath.IncludeSolutionAnalyzerReferences)`
`288`		`- ChecksumCollection.Find(solution.AnalyzerReferences, AnalyzerReferences, searchingChecksumsLeft, onAssetFound, cancellationToken);`
	`290`	`+ ChecksumCollection.Find(solution.AnalyzerReferences, AnalyzerReferences, searchingChecksumsLeft, onAssetFound, arg, cancellationToken);`
`289`	`291`	`}`
`290`	`292`
`291`	`293`	`if (searchingChecksumsLeft.Count == 0)`
`@@ -304,7 +306,7 @@ public async Task FindAsync(`
`304`	`306`	`if (projectState != null &&`
`305`	`307`	`projectState.TryGetStateChecksums(out var projectStateChecksums))`
`306`	`308`	`{`
`307`		`- await projectStateChecksums.FindAsync(projectState, assetPath, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);`
	`309`	`+ await projectStateChecksums.FindAsync(projectState, assetPath, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);`
`308`	`310`	`}`
`309`	`311`	`}`
`310`	`312`	`else`
`@@ -327,7 +329,7 @@ public async Task FindAsync(`
`327`	`329`	`if (!projectState.TryGetStateChecksums(out var projectStateChecksums))`
`328`	`330`	`continue;`
`329`	`331`
`330`		`- await projectStateChecksums.FindAsync(projectState, assetPath, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);`
	`332`	`+ await projectStateChecksums.FindAsync(projectState, assetPath, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);`
`331`	`333`	`}`
`332`	`334`	`}`
`333`	`335`	`}`
`@@ -431,11 +433,12 @@ public static ProjectStateChecksums Deserialize(ObjectReader reader)`
`431`	`433`	`return result;`
`432`	`434`	`}`
`433`	`435`
`434`		`- public async Task FindAsync(`
	`436`	`+ public async Task FindAsync<TArg>(`
`435`	`437`	`ProjectState state,`
`436`	`438`	`AssetPath assetPath,`
`437`	`439`	`HashSet<Checksum> searchingChecksumsLeft,`
`438`		`- Action<Checksum, object> onAssetFound,`
	`440`	`+ Action<Checksum, object, TArg> onAssetFound,`
	`441`	`+ TArg arg,`
`439`	`442`	`CancellationToken cancellationToken)`
`440`	`443`	`{`
`441`	`444`	`cancellationToken.ThrowIfCancellationRequested();`
`@@ -449,38 +452,38 @@ public async Task FindAsync(`
`449`	`452`	`if (assetPath.IncludeProjects)`
`450`	`453`	`{`
`451`	`454`	`if (assetPath.IncludeProjectStateChecksums && searchingChecksumsLeft.Remove(Checksum))`
`452`		`- onAssetFound(Checksum, this);`
	`455`	`+ onAssetFound(Checksum, this, arg);`
`453`	`456`
`454`	`457`	`if (assetPath.IncludeProjectAttributes && searchingChecksumsLeft.Remove(Info))`
`455`		`- onAssetFound(Info, state.ProjectInfo.Attributes);`
	`458`	`+ onAssetFound(Info, state.ProjectInfo.Attributes, arg);`
`456`	`459`
`457`	`460`	`if (assetPath.IncludeProjectCompilationOptions && searchingChecksumsLeft.Remove(CompilationOptions))`
`458`	`461`	`{`
`459`	`462`	`var compilationOptions = state.CompilationOptions ?? throw new InvalidOperationException("We should not be trying to serialize a project with no compilation options; RemoteSupportedLanguages.IsSupported should have filtered it out.");`
`460`		`- onAssetFound(CompilationOptions, compilationOptions);`
	`463`	`+ onAssetFound(CompilationOptions, compilationOptions, arg);`
`461`	`464`	`}`
`462`	`465`
`463`	`466`	`if (assetPath.IncludeProjectParseOptions && searchingChecksumsLeft.Remove(ParseOptions))`
`464`	`467`	`{`
`465`	`468`	`var parseOptions = state.ParseOptions ?? throw new InvalidOperationException("We should not be trying to serialize a project with no parse options; RemoteSupportedLanguages.IsSupported should have filtered it out.");`
`466`		`- onAssetFound(ParseOptions, parseOptions);`
	`469`	`+ onAssetFound(ParseOptions, parseOptions, arg);`
`467`	`470`	`}`
`468`	`471`
`469`	`472`	`if (assetPath.IncludeProjectProjectReferences)`
`470`		`- ChecksumCollection.Find(state.ProjectReferences, ProjectReferences, searchingChecksumsLeft, onAssetFound, cancellationToken);`
	`473`	`+ ChecksumCollection.Find(state.ProjectReferences, ProjectReferences, searchingChecksumsLeft, onAssetFound, arg, cancellationToken);`
`471`	`474`
`472`	`475`	`if (assetPath.IncludeProjectMetadataReferences)`
`473`		`- ChecksumCollection.Find(state.MetadataReferences, MetadataReferences, searchingChecksumsLeft, onAssetFound, cancellationToken);`
	`476`	`+ ChecksumCollection.Find(state.MetadataReferences, MetadataReferences, searchingChecksumsLeft, onAssetFound, arg, cancellationToken);`
`474`	`477`
`475`	`478`	`if (assetPath.IncludeProjectAnalyzerReferences)`
`476`		`- ChecksumCollection.Find(state.AnalyzerReferences, AnalyzerReferences, searchingChecksumsLeft, onAssetFound, cancellationToken);`
	`479`	`+ ChecksumCollection.Find(state.AnalyzerReferences, AnalyzerReferences, searchingChecksumsLeft, onAssetFound, arg, cancellationToken);`
`477`	`480`	`}`
`478`	`481`
`479`	`482`	`if (assetPath.IncludeDocuments)`
`480`	`483`	`{`
`481`		`- await ChecksumCollection.FindAsync(assetPath, state.DocumentStates, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);`
`482`		`- await ChecksumCollection.FindAsync(assetPath, state.AdditionalDocumentStates, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);`
`483`		`- await ChecksumCollection.FindAsync(assetPath, state.AnalyzerConfigDocumentStates, searchingChecksumsLeft, onAssetFound, cancellationToken).ConfigureAwait(false);`
	`484`	`+ await ChecksumCollection.FindAsync(assetPath, state.DocumentStates, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);`
	`485`	`+ await ChecksumCollection.FindAsync(assetPath, state.AdditionalDocumentStates, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);`
	`486`	`+ await ChecksumCollection.FindAsync(assetPath, state.AnalyzerConfigDocumentStates, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);`
`484`	`487`	`}`
`485`	`488`	`}`
`486`	`489`	`}`
`@@ -502,24 +505,25 @@ public void AddAllTo(HashSet<Checksum> checksums)`
`502`	`505`	`checksums.AddIfNotNullChecksum(this.Text);`
`503`	`506`	`}`
`504`	`507`
`505`		`- public async Task FindAsync(`
	`508`	`+ public async Task FindAsync<TArg>(`
`506`	`509`	`AssetPath assetPath,`
`507`	`510`	`TextDocumentState state,`
`508`	`511`	`HashSet<Checksum> searchingChecksumsLeft,`
`509`		`- Action<Checksum, object> onAssetFound,`
	`512`	`+ Action<Checksum, object, TArg> onAssetFound,`
	`513`	`+ TArg arg,`
`510`	`514`	`CancellationToken cancellationToken)`
`511`	`515`	`{`
`512`	`516`	`Debug.Assert(state.TryGetStateChecksums(out var stateChecksum) && this == stateChecksum);`
`513`	`517`
`514`	`518`	`cancellationToken.ThrowIfCancellationRequested();`
`515`	`519`
`516`	`520`	`if (assetPath.IncludeDocumentAttributes && searchingChecksumsLeft.Remove(Info))`
`517`		`- onAssetFound(Info, state.Attributes);`
	`521`	`+ onAssetFound(Info, state.Attributes, arg);`
`518`	`522`
`519`	`523`	`if (assetPath.IncludeDocumentText && searchingChecksumsLeft.Remove(Text))`
`520`	`524`	`{`
`521`	`525`	`var text = await SerializableSourceText.FromTextDocumentStateAsync(state, cancellationToken).ConfigureAwait(false);`
`522`		`- onAssetFound(Text, text);`
	`526`	`+ onAssetFound(Text, text, arg);`
`523`	`527`	`}`
`524`	`528`	`}`
`525`	`529`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,15 +60,16 @@ public async Task AddAssetsAsync(`
`60`	`60`
`61`	`61`	`await FindAssetsAsync(`
`62`	`62`	`assetPath, checksumsToFind,`
`63`		`- (checksum, asset) => assetMap[checksum] = asset,`
	`63`	`+ static (checksum, asset, assetMap) => assetMap[checksum] = asset,`
	`64`	`+ assetMap,`
`64`	`65`	`cancellationToken).ConfigureAwait(false);`
`65`	`66`
`66`	`67`	`Contract.ThrowIfTrue(checksumsToFind.Count > 0);`
`67`	`68`	`Contract.ThrowIfTrue(assetMap.Count != numberOfChecksumsToSearch);`
`68`	`69`	`}`
`69`	`70`
`70`		`- private async Task FindAssetsAsync(`
`71`		`- AssetPath assetPath, HashSet<Checksum> remainingChecksumsToFind, Action<Checksum, object> onAssetFound, CancellationToken cancellationToken)`
	`71`	`+ private async Task FindAssetsAsync<TArg>(`
	`72`	`+ AssetPath assetPath, HashSet<Checksum> remainingChecksumsToFind, Action<Checksum, object, TArg> onAssetFound, TArg arg, CancellationToken cancellationToken)`
`72`	`73`	`{`
`73`	`74`	`var solutionState = this.CompilationState;`
`74`	`75`
`@@ -77,13 +78,13 @@ private async Task FindAssetsAsync(`
`77`	`78`	`// If we're not in a project cone, start the search at the top most state-checksum corresponding to the`
`78`	`79`	`// entire solution.`
`79`	`80`	`Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(out var stateChecksums));`
`80`		`- await stateChecksums.FindAsync(solutionState, this.ProjectCone, assetPath, remainingChecksumsToFind, onAssetFound, cancellationToken).ConfigureAwait(false);`
	`81`	`+ await stateChecksums.FindAsync(solutionState, this.ProjectCone, assetPath, remainingChecksumsToFind, onAssetFound, arg, cancellationToken).ConfigureAwait(false);`
`81`	`82`	`}`
`82`	`83`	`else`
`83`	`84`	`{`
`84`	`85`	`// Otherwise, grab the top-most state checksum for this cone and search within that.`
`85`	`86`	`Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(this.ProjectCone.RootProjectId, out var stateChecksums));`
`86`		`- await stateChecksums.FindAsync(solutionState, this.ProjectCone, assetPath, remainingChecksumsToFind, onAssetFound, cancellationToken).ConfigureAwait(false);`
	`87`	`+ await stateChecksums.FindAsync(solutionState, this.ProjectCone, assetPath, remainingChecksumsToFind, onAssetFound, arg, cancellationToken).ConfigureAwait(false);`
`87`	`88`	`}`
`88`	`89`	`}`
`89`	`90`