private bool TryGetVsHierarchyAndItemId( Document document, [NotNullWhen(true)] out IVsHierarchy?hierarchy, out uint itemID ) { AssertIsForeground(); if ( document.Project.Solution.Workspace is VisualStudioWorkspace visualStudioWorkspace && document.FilePath is object ) { hierarchy = visualStudioWorkspace.GetHierarchy(document.Project.Id); if (hierarchy is object) { itemID = hierarchy.TryGetItemId(document.FilePath); if (itemID != VSConstants.VSITEMID_NIL) { return(true); } } } hierarchy = null; itemID = (uint)VSConstants.VSITEMID.Nil; return(false); }
public IUnconfiguredProjectVsServicesMock ImplementVsHierarchy(IVsHierarchy?hierarchy) { SetupGet <IVsHierarchy?>(m => m.VsHierarchy) .Returns(hierarchy); return(this); }
private IVsProject?TryGetProjectOfHierarchy(IVsHierarchy?hierarchy) { // The invisible editor manager will fail in cases where the IVsProject passed to it is not consistent with // the IVsProject known to IVsSolution (e.g. if the object is a wrapper like AbstractHostObject created by // the CPS-based project system). This method returns an IVsProject instance known to the solution, or null // if the project could not be determined. if (hierarchy == null) { return(null); } if (!ErrorHandler.Succeeded(hierarchy.GetGuidProperty( (uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID.VSHPROPID_ProjectIDGuid, out var projectId))) { return(null); } var solution = (IVsSolution)_serviceProvider.GetService(typeof(SVsSolution)); if (!ErrorHandler.Succeeded(solution.GetProjectOfGuid(projectId, out var projectHierarchy))) { return(null); } return(projectHierarchy as IVsProject); }
private static void AssertFailed(int result, IVsHierarchy?hierarchy, uint itemid, IVsContainedLanguageFactory?containedLanguageFactory) { Assert.Equal(VSConstants.E_FAIL, result); Assert.Null(hierarchy); Assert.Null(containedLanguageFactory); Assert.Equal((uint)VSConstants.VSITEMID.Nil, itemid); }
public bool IsProjectCpsBased(string projectPath) { IVsHierarchy?projectHierarchy = GetProjectHierarchy(projectPath); var isCps = projectHierarchy.IsCapabilityMatch("CPS"); return(isCps); }
public static bool TryGetParentHierarchy( this IVsHierarchy hierarchy, [NotNullWhen(returnValue: true)] out IVsHierarchy?parentHierarchy ) => hierarchy.TryGetProperty <IVsHierarchy>( __VSHPROPID.VSHPROPID_ParentHierarchy, out parentHierarchy );
private static DesignTimeAssemblyResolution CreateInstance(IVsHierarchy?hierarchy = null) { hierarchy ??= IVsHierarchyFactory.Create(); IUnconfiguredProjectVsServices projectVsServices = IUnconfiguredProjectVsServicesFactory.Implement(() => hierarchy); return(new DesignTimeAssemblyResolution(projectVsServices)); }
/// <summary> /// Tries to set a build property on the project. /// </summary> public static async Task <bool> TrySetBuildPropertyAsync(this Project project, string name, string value, _PersistStorageType storageType = _PersistStorageType.PST_USER_FILE) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); IVsHierarchy?hierarchy = await project.ToHierarchyAsync(); return(hierarchy != null && hierarchy.TrySetBuildProperty(name, value, storageType)); }
/// <summary> /// Returns whether the project is a 'Shared' project. /// </summary> public static async Task <bool> IsSharedProjectAsync(this Project project) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); IVsHierarchy?hierarchy = await project.ToHierarchyAsync(); return(hierarchy?.IsSharedAssetsProject() ?? false); }
public bool RemoveSuppressions(bool selectedErrorListEntriesOnly, IVsHierarchy?projectHierarchy) { if (_tableControl == null) { return(false); } var shouldFixInProject = GetShouldFixInProjectDelegate(_vsHierarchyItemManager, _projectMap, projectHierarchy); return(ApplySuppressionFix(shouldFixInProject, selectedErrorListEntriesOnly, isAddSuppression: false, isSuppressionInSource: false, onlyCompilerDiagnostics: false, showPreviewChangesDialog: true)); }
public int GetContainedLanguageFactoryForFile(string filePath, out IVsHierarchy?hierarchy, out uint itemid, out IVsContainedLanguageFactory?containedLanguageFactory) { (itemid, hierarchy, containedLanguageFactory) = _projectVsServices.ThreadingService.ExecuteSynchronously(() => { return(GetContainedLanguageFactoryForFileAsync(filePath)); }); return((hierarchy == null || containedLanguageFactory == null) ? HResult.Fail : HResult.OK); }
private bool TryGetNavigationAPIRequiredArguments( DefinitionItem definitionItem, string?rqName, CancellationToken cancellationToken, [NotNullWhen(true)] out IVsHierarchy?hierarchy, out uint itemID, [NotNullWhen(true)] out IVsSymbolicNavigationNotify?navigationNotify ) { AssertIsForeground(); hierarchy = null; navigationNotify = null; itemID = (uint)VSConstants.VSITEMID.Nil; if (rqName == null) { return(false); } var sourceLocations = definitionItem.SourceSpans; if (!sourceLocations.Any()) { return(false); } var documents = sourceLocations.SelectAsArray(loc => loc.Document); // We can only pass one itemid to IVsSymbolicNavigationNotify, so prefer itemids from // documents we consider to be "generated" to give external language services the best // chance of participating. var generatedDocuments = documents.WhereAsArray( d => d.IsGeneratedCode(cancellationToken) ); var documentToUse = generatedDocuments.FirstOrDefault() ?? documents.First(); if (!TryGetVsHierarchyAndItemId(documentToUse, out hierarchy, out itemID)) { return(false); } navigationNotify = hierarchy as IVsSymbolicNavigationNotify; if (navigationNotify == null) { return(false); } return(true); }
/// <summary> /// Returns the unique project id as identified in the solution. /// </summary> public static async Task <Guid?> GetProjectGuidAsync(this Project project) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); IVsHierarchy?hierarchy = await project.ToHierarchyAsync(); if (hierarchy != null && hierarchy.GetGuidProperty((uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID.VSHPROPID_ProjectIDGuid, out Guid id) == VSConstants.S_OK) { return(id); } return(null); }
private Project?GetProject(IVsHierarchy?hierarchy) { if (hierarchy != null) { var projectMap = _workspace.Services.GetRequiredService <IHierarchyItemToProjectIdMap>(); var projectHierarchyItem = _vsHierarchyItemManager.GetHierarchyItem(hierarchy, VSConstants.VSITEMID_ROOT); if (projectMap.TryGetProjectId(projectHierarchyItem, targetFrameworkMoniker: null, out var projectId)) { return(_workspace.CurrentSolution.GetProject(projectId)); } } return(null); }
/// <remarks> /// <para>The optional project is used to obtain an <see cref="IVsProject"/> instance. When this instance is /// provided, Visual Studio will use <see cref="IVsProject.IsDocumentInProject"/> to attempt to locate the /// specified file within a project. If no project is specified, Visual Studio falls back to using /// <see cref="IVsUIShellOpenDocument4.IsDocumentInAProject2"/>, which performs a much slower query of all /// projects in the solution.</para> /// </remarks> public InvisibleEditor(IServiceProvider serviceProvider, string filePath, IVsHierarchy?hierarchy, bool needsSave, bool needsUndoDisabled) : base(serviceProvider.GetMefService <IThreadingContext>(), assertIsForeground: true) { _serviceProvider = serviceProvider; _filePath = filePath; _needsSave = needsSave; var invisibleEditorManager = (IIntPtrReturningVsInvisibleEditorManager)serviceProvider.GetService(typeof(SVsInvisibleEditorManager)); var vsProject = hierarchy as IVsProject; Marshal.ThrowExceptionForHR(invisibleEditorManager.RegisterInvisibleEditor(filePath, vsProject, 0, null, out var invisibleEditorPtr)); try { _invisibleEditor = (IVsInvisibleEditor)Marshal.GetUniqueObjectForIUnknown(invisibleEditorPtr); var docDataPtr = IntPtr.Zero; Marshal.ThrowExceptionForHR(_invisibleEditor.GetDocData(fEnsureWritable: needsSave ? 1 : 0, riid: typeof(IVsTextLines).GUID, ppDocData: out docDataPtr)); try { var docData = Marshal.GetObjectForIUnknown(docDataPtr); _vsTextLines = (IVsTextLines)docData; var editorAdapterFactoryService = serviceProvider.GetMefService <IVsEditorAdaptersFactoryService>(); _buffer = editorAdapterFactoryService.GetDocumentBuffer(_vsTextLines); if (needsUndoDisabled) { Marshal.ThrowExceptionForHR(_vsTextLines.GetUndoManager(out _manager)); Marshal.ThrowExceptionForHR(((IVsUndoState)_manager).IsEnabled(out var isEnabled)); _needsUndoRestored = isEnabled != 0; if (_needsUndoRestored) { _manager.DiscardFrom(null); // Discard the undo history for this document _manager.Enable(0); // Disable Undo for this document } } } finally { Marshal.Release(docDataPtr); } } finally { // We need to clean up the extra reference we have, now that we have an RCW holding onto the object. Marshal.Release(invisibleEditorPtr); } }
private static VsContainedLanguageComponentsFactory CreateInstance( IVsProject4 project, IVsContainedLanguageFactory?containedLanguageFactory = null, IVsHierarchy?hierarchy = null, ProjectProperties?properties = null, IActiveWorkspaceProjectContextHost?projectContextHost = null) { var serviceProvider = IOleAsyncServiceProviderFactory.ImplementQueryServiceAsync(containedLanguageFactory, new Guid(LanguageServiceId)); var projectVsServices = new IUnconfiguredProjectVsServicesMock(); projectVsServices.ImplementVsHierarchy(hierarchy); projectVsServices.ImplementVsProject(project); projectVsServices.ImplementThreadingService(IProjectThreadingServiceFactory.Create()); projectVsServices.ImplementActiveConfiguredProjectProperties(properties); return(CreateInstance(serviceProvider, projectVsServices.Object, projectContextHost)); }
public bool RemoveSuppressions(bool selectedErrorListEntriesOnly, IVsHierarchy?projectHierarchy) { var errorReportingService = _workspace.Services.GetRequiredService <IErrorReportingService>(); try { return(_implementation.RemoveSuppressions(selectedErrorListEntriesOnly, projectHierarchy)); } catch (Exception ex) { errorReportingService.ShowGlobalErrorInfo( string.Format(ServicesVSResources.Error_updating_suppressions_0, ex.Message), new InfoBarUI( WorkspacesResources.Show_Stack_Trace, InfoBarUI.UIKind.HyperLink, () => errorReportingService.ShowDetailedErrorInfo(ex), closeAfterAction: true)); return(false); } }
public bool AddSuppressions(IVsHierarchy?projectHierarchy) { if (_tableControl == null) { return(false); } var shouldFixInProject = GetShouldFixInProjectDelegate(_vsHierarchyItemManager, _projectMap, projectHierarchy); // Apply suppressions fix in global suppressions file for non-compiler diagnostics and // in source only for compiler diagnostics. var diagnosticsToFix = GetDiagnosticsToFix(shouldFixInProject, selectedEntriesOnly: false, isAddSuppression: true); if (!ApplySuppressionFix(diagnosticsToFix, shouldFixInProject, filterStaleDiagnostics: false, isAddSuppression: true, isSuppressionInSource: false, onlyCompilerDiagnostics: false, showPreviewChangesDialog: false)) { return(false); } return(ApplySuppressionFix(diagnosticsToFix, shouldFixInProject, filterStaleDiagnostics: false, isAddSuppression: true, isSuppressionInSource: true, onlyCompilerDiagnostics: true, showPreviewChangesDialog: false)); }
public static IVsSolutionBuildManager2 Create( IVsUpdateSolutionEvents?solutionEventsListener = null, IVsHierarchy?hierarchyToBuild = null, bool isBuilding = false, bool cancelBuild = false) { var buildManager = new Mock <IVsSolutionBuildManager2>(); solutionEventsListener ??= IVsUpdateSolutionEventsFactory.Create(); hierarchyToBuild ??= IVsHierarchyFactory.Create(); int isBusy = isBuilding ? 1 : 0; buildManager.Setup(b => b.QueryBuildManagerBusy(out isBusy)) .Returns(VSConstants.S_OK); if (hierarchyToBuild != null) { int onBuildStartedWithReturn() { solutionEventsListener !.UpdateSolution_Begin(It.IsAny <int>()); if (cancelBuild) { solutionEventsListener.UpdateSolution_Cancel(); } else { solutionEventsListener.UpdateSolution_Done(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <int>()); } return(VSConstants.S_OK); } uint dwFlags = (uint)(VSSOLNBUILDUPDATEFLAGS.SBF_SUPPRESS_SAVEBEFOREBUILD_QUERY | VSSOLNBUILDUPDATEFLAGS.SBF_OPERATION_BUILD); buildManager.Setup(b => b.StartSimpleUpdateProjectConfiguration(hierarchyToBuild, It.IsAny <IVsHierarchy>(), It.IsAny <string>(), dwFlags, It.IsAny <uint>(), It.IsAny <int>())) .Returns(onBuildStartedWithReturn); } return(buildManager.Object); }
public bool AddSuppressions(IVsHierarchy?projectHierarchy) { var errorReportingService = _workspace.Services.GetRequiredService <IErrorReportingService>(); try { return(_implementation.AddSuppressions(projectHierarchy)); } catch (Exception ex) { errorReportingService.ShowGlobalErrorInfo( string.Format(ServicesVSResources.Error_updating_suppressions_0, ex.Message), TelemetryFeatureName.LegacySuppressionFix, ex, new InfoBarUI( WorkspacesResources.Show_Stack_Trace, InfoBarUI.UIKind.HyperLink, () => errorReportingService.ShowDetailedErrorInfo(ex), closeAfterAction: true)); return(false); } }
public static IVsSolutionBuildManager2 Create( IVsUpdateSolutionEvents?solutionEventsListener = null, IVsHierarchy?hierarchyToBuild = null, bool isBuilding = false, bool cancelBuild = false) { var buildManager = new Mock <IVsSolutionBuildManager2>(); solutionEventsListener ??= IVsUpdateSolutionEventsFactory.Create(); hierarchyToBuild ??= IVsHierarchyFactory.Create(); int isBusy = isBuilding ? 1 : 0; buildManager.Setup(b => b.QueryBuildManagerBusy(out isBusy)) .Returns(VSConstants.S_OK); if (hierarchyToBuild != null) { int onBuildStartedWithReturn() { solutionEventsListener.UpdateSolution_Begin(It.IsAny <int>()); if (cancelBuild) { solutionEventsListener.UpdateSolution_Cancel(); } else { solutionEventsListener.UpdateSolution_Done(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <int>()); } return(VSConstants.S_OK); } buildManager.Setup(b => b.StartUpdateSpecificProjectConfigurations(It.IsAny <uint>(), It.IsAny <IVsHierarchy[]>(), It.IsAny <IVsCfg[]>(), It.IsAny <uint[]>(), It.IsAny <uint[]>(), It.IsAny <uint[]>(), It.IsAny <uint>(), It.IsAny <int>())) .Returns(onBuildStartedWithReturn); } return(buildManager.Object); }
public void OnAfterGlobalSymbolRenamed(string projectPath, IEnumerable <string> filePaths, string rqName, string newName) { IVsHierarchy?projectHierarchy = GetProjectHierarchy(projectPath); if (projectHierarchy == null) { return; } if (!(projectHierarchy is IVsHierarchyRefactorNotify refactorNotify)) { return; } uint[] ids = GetIdsForFiles(projectHierarchy, filePaths).ToArray(); refactorNotify.OnGlobalSymbolRenamed(cItemsAffected: (uint)ids.Length, rgItemsAffected: ids, cRQNames: 1, rglpszRQName: new[] { rqName }, lpszNewName: newName); }
public static ISolutionBuildManager Create( IVsUpdateSolutionEvents?solutionEventsListener = null, IVsHierarchy?hierarchyToBuild = null, bool isBuilding = false, bool cancelBuild = false) { var buildManager = new Mock <ISolutionBuildManager>(); solutionEventsListener ??= IVsUpdateSolutionEventsFactory.Create(); hierarchyToBuild ??= IVsHierarchyFactory.Create(); int isBusy = isBuilding ? 1 : 0; buildManager.Setup(b => b.QueryBuildManagerBusy()) .Returns(isBusy); if (hierarchyToBuild != null) { void onBuildStartedWithReturn(IVsHierarchy[] _, uint[] __, uint ___) { solutionEventsListener !.UpdateSolution_Begin(It.IsAny <int>()); if (cancelBuild) { solutionEventsListener.UpdateSolution_Cancel(); } else { solutionEventsListener.UpdateSolution_Done(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <int>()); } } buildManager.Setup(b => b.StartUpdateSpecificProjectConfigurations(It.IsAny <IVsHierarchy[]>(), It.IsAny <uint[]>(), It.IsAny <uint>())) .Callback((System.Action <IVsHierarchy[], uint[], uint>)onBuildStartedWithReturn); } return(buildManager.Object); }
public async Task OnBeforeGlobalSymbolRenamedAsync(string projectPath, IEnumerable <string> filePaths, string rqName, string newName) { IVsHierarchy?projectHierarchy = await GetProjectHierarchy(projectPath); if (projectHierarchy == null) { return; } if (!(projectHierarchy is IVsHierarchyRefactorNotify refactorNotify)) { return; } uint[] ids = GetIdsForFiles(projectHierarchy, filePaths).ToArray(); refactorNotify.OnBeforeGlobalSymbolRenamed(cItemsAffected: (uint)ids.Length, rgItemsAffected: ids, cRQNames: (uint)1, rglpszRQName: new[] { rqName }, lpszNewName: newName, promptContinueOnFail: 1); }
public IReadOnlyDictionary <string, IEnumerable <DiagnosticDescriptor> > GetAllDiagnosticDescriptors(IVsHierarchy?hierarchy) { var currentSolution = _workspace.CurrentSolution; var infoCache = _diagnosticService.AnalyzerInfoCache; var hostAnalyzers = currentSolution.State.Analyzers; if (hierarchy == null) { return(Transform(hostAnalyzers.GetDiagnosticDescriptorsPerReference(infoCache))); } // Analyzers are only supported for C# and VB currently. var projectsWithHierarchy = currentSolution.Projects .Where(p => p.Language is LanguageNames.CSharp or LanguageNames.VisualBasic) .Where(p => _workspace.GetHierarchy(p.Id) == hierarchy); if (projectsWithHierarchy.Count() <= 1) { var project = projectsWithHierarchy.FirstOrDefault(); if (project == null) { return(Transform(hostAnalyzers.GetDiagnosticDescriptorsPerReference(infoCache))); } else { return(Transform(hostAnalyzers.GetDiagnosticDescriptorsPerReference(infoCache, project))); } } else { // Multiple workspace projects map to the same hierarchy, return a union of descriptors for all projects. // For example, this can happen for web projects where we create on the fly projects for aspx files. var descriptorsMap = ImmutableDictionary.CreateBuilder <string, IEnumerable <DiagnosticDescriptor> >(); foreach (var project in projectsWithHierarchy) { var descriptorsPerReference = hostAnalyzers.GetDiagnosticDescriptorsPerReference(infoCache, project); foreach (var(displayName, descriptors) in descriptorsPerReference) { if (descriptorsMap.TryGetValue(displayName, out var existingDescriptors)) { descriptorsMap[displayName] = existingDescriptors.Concat(descriptors).Distinct(); } else { descriptorsMap[displayName] = descriptors; } } } return(descriptorsMap.ToImmutable()); } }
void IRunningDocumentTableEventListener.OnOpenDocument(string moniker, ITextBuffer textBuffer, IVsHierarchy?hierarchy, IVsWindowFrame?_) => TryOpeningDocumentsForMoniker(moniker, textBuffer, hierarchy);
void IRunningDocumentTableEventListener.OnOpenDocument(string moniker, ITextBuffer textBuffer, IVsHierarchy?hierarchy, IVsWindowFrame?windowFrame) => NotifyOnDocumentOpened(moniker, textBuffer);
void IRunningDocumentTableEventListener.OnOpenDocument(string moniker, ITextBuffer textBuffer, IVsHierarchy?hierarchy, IVsWindowFrame?windowFrame) { if (TryParseGeneratedFilePath(moniker, out var projectId, out var generatorTypeName, out var generatorAssemblyName, out var generatedSourceHintName)) { // Attach to the text buffer if we haven't already if (!_openFiles.TryGetValue(moniker, out OpenSourceGeneratedFile openFile)) { openFile = new OpenSourceGeneratedFile(this, textBuffer, _visualStudioWorkspace, projectId, generatorTypeName, generatorAssemblyName, generatedSourceHintName, _threadingContext); _openFiles.Add(moniker, openFile); _threadingContext.JoinableTaskFactory.Run(() => openFile.UpdateBufferContentsAsync(CancellationToken.None)); // Update the RDT flags to ensure the file can't be saved or appears in any MRUs as it's a temporary generated file name. var cookie = ((IVsRunningDocumentTable4)_runningDocumentTable).GetDocumentCookie(moniker); ErrorHandler.ThrowOnFailure(_runningDocumentTable.ModifyDocumentFlags(cookie, (uint)(_VSRDTFLAGS.RDT_CantSave | _VSRDTFLAGS.RDT_DontAddToMRU), fSet: 1)); } if (windowFrame != null) { openFile.SetWindowFrame(windowFrame); } } }
public void RunAnalyzers(IVsHierarchy?hierarchy) { var project = GetProject(hierarchy); var solution = _workspace.CurrentSolution; var projectOrSolutionName = project?.Name ?? PathUtilities.GetFileName(solution.FilePath); // Add a message to VS status bar that we are running code analysis. var statusBar = _serviceProvider?.GetService(typeof(SVsStatusbar)) as IVsStatusbar; var totalProjectCount = project != null ? 1 : (uint)solution.ProjectIds.Count; var statusBarUpdater = statusBar != null ? new StatusBarUpdater(statusBar, _threadingContext, projectOrSolutionName, totalProjectCount) : null; // Force complete analyzer execution in background. var asyncToken = _listener.BeginAsyncOperation($"{nameof(VisualStudioDiagnosticAnalyzerService)}_{nameof(RunAnalyzers)}"); Task.Run(async() => { try { var onProjectAnalyzed = statusBarUpdater != null ? statusBarUpdater.OnProjectAnalyzed : (Action <Project>)((Project _) => { }); await _diagnosticService.ForceAnalyzeAsync(solution, onProjectAnalyzed, project?.Id, CancellationToken.None).ConfigureAwait(false); // If user has disabled live analyzer execution for any project(s), i.e. set RunAnalyzersDuringLiveAnalysis = false, // then ForceAnalyzeAsync will not cause analyzers to execute. // We explicitly fetch diagnostics for such projects and report these as "Host" diagnostics. HandleProjectsWithDisabledAnalysis(); } finally { statusBarUpdater?.Dispose(); } }).CompletesAsyncOperation(asyncToken); return; void HandleProjectsWithDisabledAnalysis() { RoslynDebug.Assert(solution != null); // First clear all special host diagostics for all involved projects. var projects = project != null?SpecializedCollections.SingletonEnumerable(project) : solution.Projects; foreach (var project in projects) { _hostDiagnosticUpdateSource.ClearDiagnosticsForProject(project.Id, key: this); } // Now compute the new host diagostics for all projects with disabled analysis. var projectsWithDisabledAnalysis = projects.Where(p => !p.State.RunAnalyzers).ToImmutableArrayOrEmpty(); if (!projectsWithDisabledAnalysis.IsEmpty) { // Compute diagnostics by overidding project's RunCodeAnalysis flag to true. var tasks = new System.Threading.Tasks.Task <ImmutableArray <DiagnosticData> > [projectsWithDisabledAnalysis.Length]; for (var index = 0; index < projectsWithDisabledAnalysis.Length; index++) { var project = projectsWithDisabledAnalysis[index]; project = project.Solution.WithRunAnalyzers(project.Id, runAnalyzers: true).GetProject(project.Id) !; tasks[index] = Task.Run( () => _diagnosticService.GetDiagnosticsAsync(project.Solution, project.Id)); } Task.WhenAll(tasks).Wait(); // Report new host diagostics. for (var index = 0; index < projectsWithDisabledAnalysis.Length; index++) { var project = projectsWithDisabledAnalysis[index]; var diagnostics = tasks[index].Result; _hostDiagnosticUpdateSource.UpdateDiagnosticsForProject(project.Id, key: this, diagnostics); } } } }
private static Func <Project, bool> GetShouldFixInProjectDelegate(IVsHierarchyItemManager vsHierarchyItemManager, IHierarchyItemToProjectIdMap projectMap, IVsHierarchy?projectHierarchy) { ProjectId?projectIdToMatch = null; if (projectHierarchy != null) { var projectHierarchyItem = vsHierarchyItemManager.GetHierarchyItem(projectHierarchy, VSConstants.VSITEMID_ROOT); if (projectMap.TryGetProjectId(projectHierarchyItem, targetFrameworkMoniker: null, out var projectId)) { projectIdToMatch = projectId; } } return(p => projectHierarchy == null || p.Id == projectIdToMatch); }