Simplify further

CyrusNajmabadi · CyrusNajmabadi · commit de7b4c573348 · 2022-05-31T14:35:19.000-07:00
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.SkeletonReferenceCache.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.SkeletonReferenceCache.cs
@@ -251,6 +251,17 @@ private sealed class SkeletonReferenceSet
             /// </summary>
             private readonly DeferredDocumentationProvider _documentationProvider;
 
+            /// <summary>
+            /// The actual assembly metadata produced from the data pointed to in <see cref="_storage"/>.
+            /// </summary>
+            private readonly AsyncLazy<AssemblyMetadata?> _metadata;
+
+            /// <summary>
+            /// Mapping from different values of <see cref="MetadataReferenceProperties"/> to the actual <see
+            /// cref="MetadataReference"/> produced for it.  Used so that if the same compilation is referenced from
+            /// different projects with/without the same properties that the right references are handed out (and shared
+            /// if possible).
+            /// </summary>
             /// <remarks>
             /// This instance should be locked when being read/written.
             /// </remarks>
@@ -264,58 +275,34 @@ public SkeletonReferenceSet(
                 _storage = storage;
                 _assemblyName = assemblyName;
                 _documentationProvider = documentationProvider;
-            }
-
-            public MetadataReference? TryGetAlreadyBuiltMetadataReference(MetadataReferenceProperties properties)
-            {
-                // lookup first and eagerly return cached value if we have it.
-                lock (_metadataReferences)
-                    return _metadataReferences.TryGetValue(properties, out var lazy) && lazy.TryGetValue(out var result) ? result : null;
-            }
-
-            public Task<MetadataReference?> GetMetadataReferenceAsync(MetadataReferenceProperties properties, CancellationToken cancellationToken)
-            {
-                AsyncLazy<MetadataReference?>? lazy;
-                lock (_metadataReferences)
-                {
-                    if (!_metadataReferences.TryGetValue(properties, out lazy))
-                    {
-                        // note: computing the reference is actually synchronous.  However, this ensures we don't have N
-                        // threads blocking on a lazy to compute the work.  Instead, we'll only occupy one thread, while
-                        // any concurrent requests asynchronously wait for that work to be one.
-                        lazy = new AsyncLazy<MetadataReference?>(c => ComputeReferenceAsync(properties, c), cacheResult: true);
-                        _metadataReferences.Add(properties, lazy);
-                    }
-                }
 
-                return lazy.GetValueAsync(cancellationToken);
-
-                Task<MetadataReference?> ComputeReferenceAsync(MetadataReferenceProperties properties, CancellationToken cancellationToken)
-                {
-                    return Task.FromResult(CreateReference(properties.Aliases, properties.EmbedInteropTypes, _documentationProvider));
-                }
+                // note: computing the assembly metadata is actually synchronous.  However, this ensures we don't have N
+                // threads blocking on a lazy to compute the work.  Instead, we'll only occupy one thread, while any
+                // concurrent requests asynchronously wait for that work to be one.
+                _metadata = new AsyncLazy<AssemblyMetadata?>(c => Task.FromResult(ComputeMetadata(_storage, c)), cacheResult: true);
             }
 
-            private MetadataReference? CreateReference(ImmutableArray<string> aliases, bool embedInteropTypes, DocumentationProvider documentationProvider)
+            private static AssemblyMetadata? ComputeMetadata(ITemporaryStreamStorage? storage, CancellationToken cancellationToken)
             {
-                if (_storage == null)
+                if (storage == null)
                     return null;
 
                 // first see whether we can use native memory directly.
-                var stream = _storage.ReadStream();
-                AssemblyMetadata metadata;
+                var stream = storage.ReadStream(cancellationToken);
 
                 if (stream is ISupportDirectMemoryAccess supportNativeMemory)
                 {
                     // this is unfortunate that if we give stream, compiler will just re-copy whole content to 
                     // native memory again. this is a way to get around the issue by we getting native memory ourselves and then
                     // give them pointer to the native memory. also we need to handle lifetime ourselves.
-                    metadata = AssemblyMetadata.Create(ModuleMetadata.CreateFromImage(supportNativeMemory.GetPointer(), (int)stream.Length));
+                    var metadata = AssemblyMetadata.Create(ModuleMetadata.CreateFromImage(supportNativeMemory.GetPointer(), (int)stream.Length));
 
                     // Tie lifetime of stream to metadata we created. It is important to tie this to the Metadata and not the
                     // metadata reference, as PE symbols hold onto just the Metadata. We can use Add here since we created
                     // a brand new object in AssemblyMetadata.Create above.
                     s_lifetime.Add(metadata, supportNativeMemory);
+
+                    return metadata;
                 }
                 else
                 {
@@ -325,14 +312,43 @@ public SkeletonReferenceSet(
 
                     // We don't deterministically release the resulting metadata since we don't know 
                     // when we should. So we leave it up to the GC to collect it and release all the associated resources.
-                    metadata = AssemblyMetadata.CreateFromStream(stream);
+                    return AssemblyMetadata.CreateFromStream(stream, leaveOpen: false);
+                }
+            }
+
+            public MetadataReference? TryGetAlreadyBuiltMetadataReference(MetadataReferenceProperties properties)
+            {
+                // lookup first and eagerly return cached value if we have it.
+                lock (_metadataReferences)
+                    return _metadataReferences.TryGetValue(properties, out var lazy) && lazy.TryGetValue(out var result) ? result : null;
+            }
+
+            public Task<MetadataReference?> GetMetadataReferenceAsync(MetadataReferenceProperties properties, CancellationToken cancellationToken)
+            {
+                AsyncLazy<MetadataReference?>? lazy;
+                lock (_metadataReferences)
+                {
+                    if (!_metadataReferences.TryGetValue(properties, out lazy))
+                    {
+                        lazy = new AsyncLazy<MetadataReference?>(c => ComputeReferenceAsync(properties, c), cacheResult: true);
+                        _metadataReferences.Add(properties, lazy);
+                    }
                 }
 
-                return metadata.GetReference(
-                    documentation: documentationProvider,
-                    aliases: aliases,
-                    embedInteropTypes: embedInteropTypes,
-                    display: _assemblyName);
+                return lazy.GetValueAsync(cancellationToken);
+
+                async Task<MetadataReference?> ComputeReferenceAsync(MetadataReferenceProperties properties, CancellationToken cancellationToken)
+                {
+                    var metadata = await _metadata.GetValueAsync(cancellationToken).ConfigureAwait(false);
+                    if (metadata == null)
+                        return null;
+
+                    return metadata.GetReference(
+                        documentation: _documentationProvider,
+                        aliases: properties.Aliases,
+                        embedInteropTypes: properties.EmbedInteropTypes,
+                        display: _assemblyName);
+                }
             }
         }
     }
