Decouple the VisualStudiorFrameworkAssemblyPathResolverFactory

This was previously using internal guts of VisualStudioWorkspaceImpl.
Now it's just using honest-to-goodness public APIs.

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

@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Design;
 using Microsoft.VisualStudio.Shell.Interop;
 
@@ -18,19 +19,29 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem
     [ExportWorkspaceServiceFactory(typeof(IFrameworkAssemblyPathResolver), ServiceLayer.Host), Shared]
     internal sealed class VisualStudiorFrameworkAssemblyPathResolverFactory : IWorkspaceServiceFactory
     {
+        private readonly IServiceProvider _serviceProvider;
+
+        [ImportingConstructor]
+        public VisualStudiorFrameworkAssemblyPathResolverFactory(SVsServiceProvider serviceProvider)
+        {
+            _serviceProvider = serviceProvider;
+        }
+
         public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
         {
-            return new Service(workspaceServices.Workspace as VisualStudioWorkspaceImpl);
+            return new Service(workspaceServices.Workspace as VisualStudioWorkspace, _serviceProvider);
         }
 
         private sealed class Service : ForegroundThreadAffinitizedObject, IFrameworkAssemblyPathResolver
         {
-            private readonly VisualStudioWorkspaceImpl _workspace;
+            private readonly VisualStudioWorkspace _workspace;
+            private readonly IServiceProvider _serviceProvider;
 
-            public Service(VisualStudioWorkspaceImpl workspace)
+            public Service(VisualStudioWorkspace workspace, IServiceProvider serviceProvider)
                 : base(assertIsForeground: false)
             {
                 _workspace = workspace;
+                _serviceProvider = serviceProvider;
             }
 
             public string ResolveAssemblyPath(
@@ -106,9 +117,9 @@ private Assembly ResolveAssembly(ProjectId projectId, string assemblyName)
                     return null;
                 }
 
-                IVsHierarchy hierarchy;
+                IVsHierarchy hierarchy = _workspace.GetHierarchy(projectId);
                 string targetMoniker;
-                if (!_workspace.TryGetHierarchy(projectId, out hierarchy) ||
+                if (hierarchy == null ||
                     !hierarchy.TryGetProperty((__VSHPROPID)__VSHPROPID4.VSHPROPID_TargetFrameworkMoniker, out targetMoniker) ||
                     targetMoniker == null)
                 {
@@ -143,9 +154,9 @@ private Assembly ResolveAssembly(ProjectId projectId, string assemblyName)
                 try
                 {
                     var frameworkProvider = new VsTargetFrameworkProvider(
-                        _workspace.GetVsService<SVsFrameworkMultiTargeting, IVsFrameworkMultiTargeting>(),
+                        (IVsFrameworkMultiTargeting)_serviceProvider.GetService(typeof(SVsFrameworkMultiTargeting)),
                         targetMoniker,
-                        _workspace.GetVsService<SVsSmartOpenScope, IVsSmartOpenScope>());
+                        (IVsSmartOpenScope)_serviceProvider.GetService(typeof(SVsSmartOpenScope)));
                     return frameworkProvider.GetReflectionAssembly(new AssemblyName(assemblyName));
                 }
                 catch (InvalidOperationException)