Provide a service to resolve an assembly name in a project context to an actual dll path.

Note: we now need to Explicitly reference 'MetadataReader' in 'System'.

This is necessary because a new reference to MS.VS.Shell.Design has a
namespace called 'Metadata', and have to now disambiguate these two names.

src/VisualStudio/Core/Def/Implementation/AnalyzerDependency/AnalyzerDependencyChecker.cs

@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis;
 using System.Reflection;
 using System.Diagnostics;
+using SystemMetadataReader = System.Reflection.Metadata.MetadataReader;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation
 {
@@ -135,7 +136,7 @@ private static AnalyzerInfo TryReadAnalyzerInfo(string filePath)
             return null;
         }
 
-        private static ImmutableArray<AssemblyIdentity> ReadReferences(MetadataReader metadataReader)
+        private static ImmutableArray<AssemblyIdentity> ReadReferences(SystemMetadataReader metadataReader)
         {
             var builder = ImmutableArray.CreateBuilder<AssemblyIdentity>();
             foreach (var referenceHandle in metadataReader.AssemblyReferences)
@@ -155,7 +156,7 @@ private static ImmutableArray<AssemblyIdentity> ReadReferences(MetadataReader me
             return builder.ToImmutable();
         }
 
-        private static AssemblyIdentity ReadAssemblyIdentity(MetadataReader metadataReader)
+        private static AssemblyIdentity ReadAssemblyIdentity(SystemMetadataReader metadataReader)
         {
             var assemblyDefinition = metadataReader.GetAssemblyDefinition();
             string name = metadataReader.GetString(assemblyDefinition.Name);
@@ -168,7 +169,7 @@ private static AssemblyIdentity ReadAssemblyIdentity(MetadataReader metadataRead
             return new AssemblyIdentity(name, version, cultureName, publicKeyOrToken, hasPublicKey: hasPublicKey);
         }
 
-        private static Guid ReadMvid(MetadataReader metadataReader)
+        private static Guid ReadMvid(SystemMetadataReader metadataReader)
         {
             var mvidHandle = metadataReader.GetModuleDefinition().Mvid;
             return metadataReader.GetGuid(mvidHandle);

src/VisualStudio/Core/Def/Implementation/EditAndContinue/VsENCRebuildableProjectImpl.cs

@@ -1002,7 +1002,7 @@ public unsafe int BuildForEnc(object pUpdatePE)
 #if DEBUG
                 fixed (byte* deltaMetadataPtr = &delta.Metadata.Bytes[0])
                 {
-                    var reader = new MetadataReader(deltaMetadataPtr, delta.Metadata.Bytes.Length);
+                    var reader = new System.Reflection.Metadata.MetadataReader(deltaMetadataPtr, delta.Metadata.Bytes.Length);
                     var moduleDef = reader.GetModuleDefinition();
 
                     log.DebugWrite("Gen {0}: MVID={1}, BaseId={2}, EncId={3}",

src/VisualStudio/Core/Def/Implementation/ProjectSystem/MetadataReferences/VisualStudioAssemblyPathResolverFactory.cs

+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Composition;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.VisualStudio.Shell.Design;
+using Microsoft.VisualStudio.Shell.Interop;
+
+namespace Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem
+{
+    [ExportWorkspaceServiceFactory(typeof(IAssemblyPathResolver), ServiceLayer.Host), Shared]
+    internal sealed class VisualStudioAssemblyPathResolverFactory : IWorkspaceServiceFactory
+    {
+        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
+        {
+            return new Service(workspaceServices.Workspace as VisualStudioWorkspaceImpl);
+        }
+
+        private sealed class Service : ForegroundThreadAffinitizedObject, IAssemblyPathResolver
+        {
+            private readonly VisualStudioWorkspaceImpl _workspace;
+
+            public Service(VisualStudioWorkspaceImpl workspace)
+                : base(assertIsForeground: false)
+            {
+                _workspace = workspace;
+            }
+
+            public string ResolveAssemblyPath(ProjectId projectId, string assemblyName)
+            {
+                this.AssertIsForeground();
+
+                if (_workspace != null)
+                {
+                    IVsHierarchy hierarchy;
+                    string targetMoniker;
+                    if (_workspace.TryGetHierarchy(projectId, out hierarchy) &&
+                        hierarchy.TryGetProperty((__VSHPROPID)__VSHPROPID4.VSHPROPID_TargetFrameworkMoniker, out targetMoniker) &&
+                        targetMoniker != null)
+                    {
+                        try
+                        {
+                            var frameworkProvider = new VsTargetFrameworkProvider(
+                                _workspace.GetVsService<SVsFrameworkMultiTargeting, IVsFrameworkMultiTargeting>(),
+                                targetMoniker,
+                                _workspace.GetVsService<SVsSmartOpenScope, IVsSmartOpenScope>());
+                            var assembly = frameworkProvider.GetReflectionAssembly(new AssemblyName(assemblyName));
+
+                            // Codebase specifies where the assembly is on disk.  However, it's in 
+                            // full URI format (i.e. file://c:/...).
+                            var codeBase = assembly.CodeBase;
+
+                            // Make an actual URI out of it.
+                            var uri = new UriBuilder(codeBase);
+
+                            // Strip off the "file://" bit.
+                            string path = Uri.UnescapeDataString(uri.Path);
+
+                            // Use FileInfo to convert the path properly (this will replace 
+                            // forward slashes with the appropriate slashes for the platform).
+                            return new FileInfo(path).FullName;
+                        }
+                        catch (InvalidOperationException)
+                        {
+                            // VsTargetFrameworkProvider throws InvalidOperationException in the 
+                            // some cases (like when targetting packs are missing).  In that case
+                            // we can't resolve this path.
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
+    }
+}

src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspaceImpl.cs

@@ -934,7 +934,7 @@ internal override DocumentId GetDocumentIdInCurrentContext(DocumentId documentId
             return matchingDocumentId ?? base.GetDocumentIdInCurrentContext(documentId);
         }
 
-        private bool TryGetHierarchy(ProjectId projectId, out IVsHierarchy hierarchy)
+        internal bool TryGetHierarchy(ProjectId projectId, out IVsHierarchy hierarchy)
         {
             hierarchy = this.GetHierarchy(projectId);
             return hierarchy != null;

src/VisualStudio/Core/Def/ServicesVisualStudio.csproj

@@ -71,6 +71,7 @@
     <Compile Include="Implementation\ProjectSystem\Interop\ICompilerOptionsHostObject.cs" />
     <Compile Include="Implementation\ProjectSystem\IVisualStudioWorkingFolder.cs" />
     <Compile Include="Implementation\ProjectSystem\MetadataReferences\VisualStudioAnalyzerAssemblyLoaderService.cs" />
+    <Compile Include="Implementation\ProjectSystem\MetadataReferences\VisualStudioAssemblyPathResolverFactory.cs" />
     <Compile Include="Implementation\ProjectSystem\RuleSets\RuleSetEventHandler.cs" />
     <Compile Include="Implementation\ProjectSystem\VisualStudioProjectTracker_IVsSolutionWorkingFoldersEvents.cs" />
     <Compile Include="Implementation\Diagnostics\MiscellaneousDiagnosticAnalyzerService.cs" />
@@ -198,6 +199,9 @@
     <Reference Include="Microsoft.VisualStudio.CallHierarchy.Package.Definitions.dll">
       <HintPath>$(DevEnvDir)\Microsoft.VisualStudio.CallHierarchy.Package.Definitions.dll</HintPath>
     </Reference>
+    <Reference Include="Microsoft.VisualStudio.Shell.Design.dll">
+      <HintPath>$(DevEnvDir)\Microsoft.VisualStudio.Shell.Design.dll</HintPath>
+    </Reference>
     <Reference Include="Microsoft.VisualStudio.TextManager.Interop.11.0, Version=11.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
       <EmbedInteropTypes>True</EmbedInteropTypes>
     </Reference>

src/Workspaces/Core/Portable/Workspace/Host/Metadata/AssemblyPathResolverFactory.cs

+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Composition;
+using Microsoft.CodeAnalysis.Host.Mef;
+
+namespace Microsoft.CodeAnalysis.Host
+{
+    [ExportWorkspaceServiceFactory(typeof(IAssemblyPathResolver), ServiceLayer.Default), Shared]
+    internal sealed class AssemblyPathResolverFactory : IWorkspaceServiceFactory
+    {
+        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
+        {
+            return new Service();
+        }
+
+        private sealed class Service : IAssemblyPathResolver
+        {
+            public Service()
+            {
+            }
+
+            public string ResolveAssemblyPath(ProjectId projectId, string assemblyName)
+            {
+                // Assembly path resolution not supported at the default workspace level.
+                return null;
+            }
+        }
+    }
+}

src/Workspaces/Core/Portable/Workspace/Host/Metadata/IAssemblyPathResolver.cs

+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+namespace Microsoft.CodeAnalysis.Host
+{
+    internal interface IAssemblyPathResolver : IWorkspaceService
+    {
+        /// <summary>
+        /// Returns null if the assembly name could not be resolved.
+        /// </summary>
+        string ResolveAssemblyPath(ProjectId project, string assemblyName);
+    }
+}

src/Workspaces/Core/Portable/Workspaces.csproj

@@ -589,7 +589,9 @@
     <Compile Include="Workspace\Host\Mef\MefWorkspaceServices.cs" />
     <Compile Include="Workspace\Host\Mef\ServiceLayer.cs" />
     <Compile Include="Workspace\Host\Documentation\IDocumentationProviderService.cs" />
+    <Compile Include="Workspace\Host\Metadata\AssemblyPathResolverFactory.cs" />
     <Compile Include="Workspace\Host\Metadata\IAnalyzerService.cs" />
+    <Compile Include="Workspace\Host\Metadata\IAssemblyPathResolver.cs" />
     <Compile Include="Workspace\Host\Metadata\MetadataReferenceCache.cs" />
     <Compile Include="Workspace\Host\Metadata\WorkspaceMetadataFileReferenceResolver.cs" />
     <Compile Include="Workspace\Host\PersistentStorage\PersistentStorageOptionsProvider.cs" />