Mix the source generator version info into the dependent checksum we get for projects

src/Workspaces/Core/Portable/Workspace/Solution/Project.cs

@@ -568,6 +568,8 @@ public Task<VersionStamp> GetSemanticVersionAsync(CancellationToken cancellation
     ///        <see cref="Project.GetDependentSemanticVersionAsync(CancellationToken)"/> changes as the project is removed, then added resulting in a version change.</item>
     /// </list>   
     /// </para>
+    /// This checksum is also affected by the <see cref="SourceGeneratorExecutionVersion"/> for this project.
+    /// As such, it is not usable across different sessions of a particular host.
     /// </remarks>
     internal Task<Checksum> GetDependentChecksumAsync(CancellationToken cancellationToken)
         => Solution.CompilationState.GetDependentChecksumAsync(this.Id, cancellationToken);

src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.RegularCompilationTracker.cs

@@ -1096,40 +1096,50 @@ public Task<Checksum> GetDependentChecksumAsync(
                     Interlocked.CompareExchange(
                         ref _lazyDependentChecksum,
                         AsyncLazy.Create(static (arg, c) =>
-                            arg.self.ComputeDependentChecksumAsync(arg.SolutionState, c),
-                            arg: (self: this, compilationState.SolutionState)),
+                            arg.self.ComputeDependentChecksumAsync(arg.compilationState, c),
+                            arg: (self: this, compilationState)),
                         null);
                 }
 
                 return _lazyDependentChecksum.GetValueAsync(cancellationToken);
             }
 
-            private async Task<Checksum> ComputeDependentChecksumAsync(SolutionState solution, CancellationToken cancellationToken)
+            private async Task<Checksum> ComputeDependentChecksumAsync(
+                SolutionCompilationState solution, CancellationToken cancellationToken)
             {
                 using var _ = ArrayBuilder<Checksum>.GetInstance(out var tempChecksumArray);
 
+                // Mix in the SG information for this project.  That way if it changes, we will have a different
+                // checksum (since semantics could have changed because of this).
+                if (solution.SourceGeneratorExecutionVersionMap.Map.TryGetValue(this.ProjectState.Id, out var executionVersion))
+                    tempChecksumArray.Add(executionVersion.Checksum);
+
                 // Get the checksum for the project itself.
                 var projectChecksum = await this.ProjectState.GetChecksumAsync(cancellationToken).ConfigureAwait(false);
                 tempChecksumArray.Add(projectChecksum);
 
-                // Calculate a checksum this project and for each dependent project that could affect semantics for
-                // this project. Ensure that the checksum calculation orders the projects consistently so that we get
-                // the same checksum across sessions of VS.  Note: we use the project filepath+name as a unique way
-                // to reference a project.  This matches the logic in our persistence-service implemention as to how
-                // information is associated with a project.
-                var transitiveDependencies = solution.GetProjectDependencyGraph().GetProjectsThatThisProjectTransitivelyDependsOn(this.ProjectState.Id);
+                // Calculate a checksum this project and for each dependent project that could affect semantics for this
+                // project. We order the projects so that we are resilient to the underlying in-memory graph structure
+                // changing this arbitrarily.  We do not want that to cause us to change our semantic version.. Note: we
+                // use the project filepath+name as a unique way to reference a project.  This matches the logic in our
+                // persistence-service implementation as to how information is associated with a project.
+                var transitiveDependencies = solution.SolutionState.GetProjectDependencyGraph().GetProjectsThatThisProjectTransitivelyDependsOn(this.ProjectState.Id);
                 var orderedProjectIds = transitiveDependencies.OrderBy(id =>
                 {
-                    var depProject = solution.GetRequiredProjectState(id);
+                    var depProject = solution.SolutionState.GetRequiredProjectState(id);
                     return (depProject.FilePath, depProject.Name);
                 });
 
                 foreach (var projectId in orderedProjectIds)
                 {
-                    var referencedProject = solution.GetRequiredProjectState(projectId);
+                    // Mix in the SG information for the dependent project.  That way if it changes, we will have a
+                    // different checksum (since semantics could have changed because of this).
+                    if (solution.SourceGeneratorExecutionVersionMap.Map.TryGetValue(projectId, out executionVersion))
+                        tempChecksumArray.Add(executionVersion.Checksum);
 
                     // Note that these checksums should only actually be calculated once, if the project is unchanged
                     // the same checksum will be returned.
+                    var referencedProject = solution.SolutionState.GetRequiredProjectState(projectId);
                     var referencedProjectChecksum = await referencedProject.GetChecksumAsync(cancellationToken).ConfigureAwait(false);
                     tempChecksumArray.Add(referencedProjectChecksum);
                 }

src/Workspaces/Core/Portable/Workspace/Solution/SourceGeneratorExecutionVersion.cs

@@ -46,6 +46,8 @@ public static SourceGeneratorExecutionVersion ReadFrom(ObjectReader reader)
 
     public override string ToString()
         => $"{MajorVersion}.{MinorVersion}";
+
+    public Checksum Checksum => new(MajorVersion, MinorVersion);
 }
 
 /// <summary>