IVsHierarchyItem IAdapter <Project, IVsHierarchyItem> .Adapt(Project from)
{
IVsHierarchy project;
if (!ErrorHandler.Succeeded(this.serviceProvider
.GetService <SVsSolution, IVsSolution> ()
.GetProjectOfUniqueName(from.UniqueName, out project)))
{
return(null);
}
return(hierarchyManager.GetHierarchyItem(project, VSConstants.VSITEMID_ROOT));
}
public IVsHierarchyItem GetActiveHierarchy()
{
return(asyncManager.Run(async() => {
await asyncManager.SwitchToMainThread();
IVsUIHierarchy uiHier;
if (ErrorHandler.Failed(hierarchyWindow.FindCommonSelectedHierarchy((uint)__VSCOMHIEROPTIONS.COMHIEROPT_RootHierarchyOnly, out uiHier)))
{
return null;
}
return hierarchyManager.GetHierarchyItem(uiHier, VSConstants.VSITEMID_ROOT);
}));
}
private (Project?, ImmutableArray <ReferenceUpdate>) GetUnusedReferencesForProjectHierarchy(IVsHierarchy projectHierarchy, CancellationToken cancellationToken)
{
if (!TryGetPropertyValue(projectHierarchy, ProjectAssetsFilePropertyName, out var projectAssetsFile) ||
!projectHierarchy.TryGetTargetFrameworkMoniker((uint)VSConstants.VSITEMID.Root, out var targetFrameworkMoniker))
{
return(null, ImmutableArray <ReferenceUpdate> .Empty);
}
var projectMap = _workspace.Services.GetRequiredService <IHierarchyItemToProjectIdMap>();
var projectHierarchyItem = _vsHierarchyItemManager.GetHierarchyItem(projectHierarchy, VSConstants.VSITEMID_ROOT);
if (!projectMap.TryGetProjectId(projectHierarchyItem, targetFrameworkMoniker, out var projectId))
{
return(null, ImmutableArray <ReferenceUpdate> .Empty);
}
var project = _workspace.CurrentSolution.GetProject(projectId);
if (project is null)
{
return(null, ImmutableArray <ReferenceUpdate> .Empty);
}
var unusedReferences = GetUnusedReferencesForProject(project, projectAssetsFile, targetFrameworkMoniker, cancellationToken);
return(project, unusedReferences);
}
private static Func <Project, bool> GetShouldFixInProjectDelegate(
IVsHierarchyItemManager vsHierarchyItemManager,
IHierarchyItemToProjectIdMap projectMap,
IVsHierarchy projectHierarchyOpt
)
{
ProjectId projectIdToMatch = null;
if (projectHierarchyOpt != null)
{
var projectHierarchyItem = vsHierarchyItemManager.GetHierarchyItem(
projectHierarchyOpt,
VSConstants.VSITEMID_ROOT
);
if (
projectMap.TryGetProjectId(
projectHierarchyItem,
targetFrameworkMoniker: null,
out var projectId
)
)
{
projectIdToMatch = projectId;
}
}
return(p => projectHierarchyOpt == null || p.Id == projectIdToMatch);
}
bool Supports(IVsHierarchyItem item, out IVsHierarchyItem actualItem)
{
actualItem = item;
if (!item.HierarchyIdentity.IsRoot)
{
return(false);
}
// We need the hierarchy fully loaded if it's not yet.
if (!item.GetProperty <bool>(__VSPROPID4.VSPROPID_IsSolutionFullyLoaded))
{
// EnsureProjectIsLoaded MUST be executed in the UI/Main thread
// Otherwise (if the Supports method is being invoked from a worker thread) duplicate keys might be generated
actualItem = asyncManager.Run(async() =>
{
await asyncManager.SwitchToMainThreadAsync();
Guid guid;
if (ErrorHandler.Succeeded(item.GetActualHierarchy().GetGuidProperty((uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID.VSHPROPID_ProjectIDGuid, out guid)) &&
// For the solution root item itself, the GUID will be empty.
guid != Guid.Empty)
{
if (ErrorHandler.Succeeded(((IVsSolution4)solution.GetValue()).EnsureProjectIsLoaded(ref guid, (uint)__VSBSLFLAGS.VSBSLFLAGS_None)))
{
return(hierarchyManager.GetHierarchyItem(item.GetActualHierarchy(), item.GetActualItemId()));
}
}
return(item);
});
}
var hierarchy = actualItem.GetActualHierarchy();
if (!(actualItem.GetActualHierarchy() is IVsProject) && !(hierarchy is FlavoredProjectBase))
{
return(false);
}
// Finally, solution folders look like projects, but they are not.
// We need to filter them out too.
var extenderObject = actualItem.GetExtenderObject();
var dteProject = extenderObject as EnvDTE.Project;
if (extenderObject != null && extenderObject.GetType().FullName == "Microsoft.VisualStudio.Project.Automation.OAProject")
{
return(false);
}
if (extenderObject != null && dteProject != null && (dteProject.Object is EnvDTE80.SolutionFolder))
{
return(false);
}
return(true);
}
/// <summary>
/// Converts a <see cref="IVsHierarchy"/> to a <see cref="IVsHierarchyItem"/>.
/// </summary>
public static IVsHierarchyItem ToHierarchyItem(this IVsHierarchy hierarchy, uint itemId)
{
if (hierarchy == null)
{
throw new ArgumentNullException(nameof(hierarchy));
}
IVsHierarchyItemManager manager = VS.GetMefService <IVsHierarchyItemManager>();
return(manager.GetHierarchyItem(hierarchy, itemId));
}
/// <summary>
/// Converts a <see cref="IVsHierarchy"/> to a <see cref="IVsHierarchyItem"/>.
/// </summary>
public static async Task <IVsHierarchyItem> ToHierarchyItemAsync(this IVsHierarchy hierarchy, uint itemId)
{
if (hierarchy == null)
{
throw new ArgumentNullException(nameof(hierarchy));
}
IVsHierarchyItemManager manager = await VS.GetMefServiceAsync <IVsHierarchyItemManager>();
return(manager.GetHierarchyItem(hierarchy, itemId));
}
private static HierarchyNode CreateNode(IVsHierarchy hierarchy, Guid identifier, IVsImageService2 imageService, IVsHierarchyItemManager hierarchyItemManager)
{
ThreadHelper.ThrowIfNotOnUIThread();
ImageMoniker collapsedIcon;
ImageMoniker expandedIcon;
string name;
bool isFolder;
name = HierarchyUtilities.GetHierarchyProperty <string>(
hierarchy,
VSConstants.VSITEMID_ROOT,
(int)__VSHPROPID.VSHPROPID_Name
);
isFolder = HierarchyUtilities.IsSolutionFolder(
hierarchyItemManager.GetHierarchyItem(hierarchy, VSConstants.VSITEMID_ROOT).HierarchyIdentity
);
collapsedIcon = imageService.GetImageMonikerForHierarchyItem(
hierarchy,
VSConstants.VSITEMID_ROOT,
(int)__VSHIERARCHYIMAGEASPECT.HIA_Icon
);
expandedIcon = imageService.GetImageMonikerForHierarchyItem(
hierarchy,
VSConstants.VSITEMID_ROOT,
(int)__VSHIERARCHYIMAGEASPECT.HIA_OpenFolderIcon
);
// Sometimes the icons can be blank.
// In those cases, use some default icons.
if (collapsedIcon.Id == 0 && collapsedIcon.Guid == default)
{
collapsedIcon = isFolder ? KnownMonikers.FolderClosed : KnownMonikers.DocumentCollection;
}
if (expandedIcon.Id == 0 && expandedIcon.Guid == default)
{
expandedIcon = isFolder ? KnownMonikers.FolderOpened : KnownMonikers.DocumentCollection;
}
return(new HierarchyNode(identifier, name, collapsedIcon, expandedIcon)
{
IsLoaded = !HierarchyUtilities.IsStubHierarchy(hierarchy),
IsFolder = isFolder
});
}
bool Supports(IVsHierarchyItem item, out IVsHierarchyItem actualItem)
{
actualItem = item;
if (!item.HierarchyIdentity.IsRoot)
{
return(false);
}
// We need the hierarchy fully loaded if it's not yet.
if (!item.GetProperty <bool>(__VSPROPID4.VSPROPID_IsSolutionFullyLoaded))
{
Guid guid;
if (ErrorHandler.Succeeded(item.GetActualHierarchy().GetGuidProperty((uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID.VSHPROPID_ProjectIDGuid, out guid)) &&
// For the solution root item itself, the GUID will be empty.
guid != Guid.Empty)
{
if (ErrorHandler.Succeeded(((IVsSolution4)solution.Value).EnsureProjectIsLoaded(ref guid, (uint)__VSBSLFLAGS.VSBSLFLAGS_None)))
{
actualItem = hierarchyManager.GetHierarchyItem(item.GetActualHierarchy(), item.GetActualItemId());
}
}
}
if (!(actualItem.GetActualHierarchy() is IVsProject))
{
return(false);
}
// Finally, solution folders look like projects, but they are not.
// We need to filter them out too.
var extenderObject = actualItem.GetExtenderObject();
var dteProject = extenderObject as EnvDTE.Project;
if (extenderObject != null && extenderObject.GetType().FullName == "Microsoft.VisualStudio.Project.Automation.OAProject")
{
return(false);
}
if (extenderObject != null && dteProject != null && (dteProject.Object is EnvDTE80.SolutionFolder))
{
return(false);
}
return(true);
}
public void SubmitResult(IRelatableItem?item)
{
if (item == null)
{
return;
}
item = DeduplicateItem(item);
PopulateAncestors(item);
_inner.SubmitResult(item);
void PopulateAncestors(IRelatableItem childItem)
{
if (childItem.ContainedByCollection != null)
{
// We've already populated this item's ancestors. It's likely an ancestor of
// another search result. This also prevents runaway in case of cycles.
return;
}
ImmutableArray <IRelation> containedByRelations = _relationProvider.GetContainedByRelationsFor(childItem.GetType());
if (containedByRelations.IsEmpty)
{
// We should never have a scenario where an item type does not have a parent.
TraceUtilities.TraceError($"No IRelation exports exist that provide parent (ContainedBy) items for type {childItem.GetType()}.");
return;
}
var allParentItems = new List <object>();
foreach (IRelation relation in containedByRelations)
{
IEnumerable <IRelatableItem>?relationParentItems = relation.CreateContainedByItems(childItem);
if (relationParentItems != null)
{
foreach (IRelatableItem parentItem in relationParentItems)
{
IRelatableItem deduplicateItem = DeduplicateItem(parentItem);
allParentItems.Add(deduplicateItem);
if (deduplicateItem.TryGetProjectNode(_targetRootNode, parentItem, out IProjectTree? projectNode))
{
uint itemId = (uint)projectNode.Identity.ToInt32();
IVsHierarchyItem hierarchyItem = _hierarchyItemManager.GetHierarchyItem(_projectVsServices.VsHierarchy, itemId);
allParentItems.Add(hierarchyItem);
}
if (deduplicateItem.ContainedByCollection == null)
{
PopulateAncestors(deduplicateItem);
}
}
}
}
childItem.ContainedByCollection = new AggregateContainedByRelationCollection(allParentItems);
return;
}
IRelatableItem DeduplicateItem(IRelatableItem item)
{
object key = GetItemKey(item);
if (_itemByKey.TryGetValue(key, out IRelatableItem existingItem))
{
return(existingItem);
}
_itemByKey.Add(key, item);
return(item);
}
}
