public static GraphNodeId GetIdForDocument(Document document) { return (GraphNodeId.GetNested( GraphNodeId.GetPartial(CodeGraphNodeIdName.Assembly, new Uri(document.Project.FilePath, UriKind.RelativeOrAbsolute)), GraphNodeId.GetPartial(CodeGraphNodeIdName.File, new Uri(document.FilePath, UriKind.RelativeOrAbsolute)))); }
private GraphNodeId GetGraphNodeId(string projectPath, GraphNode parentNode, string modelId) { var partialValues = new List <GraphNodeId> { GraphNodeId.GetPartial(CodeGraphNodeIdName.Assembly, new Uri(projectPath, UriKind.RelativeOrAbsolute)), GraphNodeId.GetPartial(CodeGraphNodeIdName.File, new Uri(modelId.ToLowerInvariant(), UriKind.RelativeOrAbsolute)) }; var parents = string.Empty; if (parentNode != null) { // to ensure Graph id for node is unique we add a hashcodes for node's parents separated by ';' parents = parentNode.Id.GetNestedValueByName <string>(CodeGraphNodeIdName.Namespace); if (string.IsNullOrEmpty(parents)) { var currentProject = parentNode.Id.GetValue(CodeGraphNodeIdName.Assembly) ?? projectPath; parents = currentProject.GetHashCode().ToString(); } } else { parents = projectPath.GetHashCode().ToString(); } parents = parents + ";" + modelId.GetHashCode(); partialValues.Add(GraphNodeId.GetPartial(CodeGraphNodeIdName.Namespace, parents)); return(GraphNodeId.GetNested(partialValues.ToArray())); }
private GraphNode GetOrCreatePackageNode(IGraphContext context, GraphNode parent, IVsPackageMetadata package) { var parentId = parent.GetValue <GraphNodeId>("Id"); var nodeId = GraphNodeId.GetNested( parentId, GraphNodeId.GetPartial(CodeGraphNodeIdName.Member, package.Id), GraphNodeId.GetPartial(CodeGraphNodeIdName.Parameter, package.VersionString)); var node = context.Graph.Nodes.Get(nodeId); if (node == null) { using (var scope = new GraphTransactionScope()) { node = context.Graph.Nodes.GetOrCreate(nodeId, package.Id, ReferencesGraphSchema.PackageCategory); node.SetValue <string>(DgmlNodeProperties.Icon, GraphIcons.Package); node.SetValue <IVsPackageMetadata>(ReferencesGraphSchema.PackageProperty, package); // Establish the relationship with the parent node. context.Graph.Links.GetOrCreate(parent, node, null, GraphCommonSchema.Contains); context.OutputNodes.Add(node); scope.Complete(); } } return(node); }
internal static async Task <GraphNodeId> GetIdForTypeAsync( ITypeSymbol symbol, Solution solution, CancellationToken cancellationToken ) { var nodes = await GetPartialsForNamespaceAndTypeAsync( symbol, true, solution, cancellationToken ) .ConfigureAwait(false); var partials = nodes.ToArray(); if (partials.Length == 1) { return(partials[0]); } else { return(GraphNodeId.GetNested(partials)); } }
private GraphNodeId GetTopLevelGraphNodeId(string projectPath, IDependencyNode nodeInfo) { var partialValues = new List <GraphNodeId> { GraphNodeId.GetPartial(CodeGraphNodeIdName.Assembly, new Uri(projectPath, UriKind.RelativeOrAbsolute)) }; var projectFolder = Path.GetDirectoryName(projectPath)?.ToLowerInvariant(); if (nodeInfo.Flags.Contains(DependencyNode.CustomItemSpec)) { if (nodeInfo.Name != null) { partialValues.Add(GraphNodeId.GetPartial( CodeGraphNodeIdName.File, new Uri(Path.Combine(projectFolder, nodeInfo.Name.ToLowerInvariant()), UriKind.RelativeOrAbsolute))); } } else { var fullItemSpecPath = MakeRooted(projectFolder, nodeInfo.Id.ItemSpec); if (!string.IsNullOrEmpty(fullItemSpecPath)) { partialValues.Add(GraphNodeId.GetPartial(CodeGraphNodeIdName.File, new Uri(fullItemSpecPath.ToLowerInvariant(), UriKind.RelativeOrAbsolute))); } } return(GraphNodeId.GetNested(partialValues.ToArray())); }
private static async Task <GraphNodeId> GetPartialForNamedTypeAsync(INamedTypeSymbol namedType, GraphNodeIdName nodeName, Solution solution, CancellationToken cancellationToken, bool isInGenericArguments = false) { // If this is a simple type, then we don't have much to do if (namedType.ContainingType == null && namedType.ConstructedFrom == namedType && namedType.Arity == 0) { return(GraphNodeId.GetPartial(nodeName, namedType.Name)); } else { // For a generic type, we need to populate "type" property with the following form: // // Type = (Name =...GenericParameterCount = GenericArguments =...ParentType =...) // // where "Name" contains a symbol name // and "GenericParameterCount" contains the number of type parameters, // and "GenericArguments" contains its type parameters' node information. // and "ParentType" contains its containing type's node information. var partials = new List <GraphNodeId>(); partials.Add(GraphNodeId.GetPartial(CodeQualifiedName.Name, namedType.Name)); if (namedType.Arity > 0) { partials.Add(GraphNodeId.GetPartial(CodeGraphNodeIdName.GenericParameterCountIdentifier, namedType.Arity.ToString())); } // For the property "GenericArguments", we only populate them // when type parameters are constructed using instance types (i.e., namedType.ConstructedFrom != namedType). // However, there is a case where we need to populate "GenericArguments" even though arguments are not marked as "constructed" // because a symbol is not marked as "constructed" when a type is constructed using its own type parameters. // To distinguish this case, we use "isInGenericArguments" flag which we pass either to populate arguments recursively or to populate "ParentType". bool hasGenericArguments = (namedType.ConstructedFrom != namedType || isInGenericArguments) && namedType.TypeArguments != null && namedType.TypeArguments.Any(); if (hasGenericArguments) { var genericArguments = new List <GraphNodeId>(); foreach (var arg in namedType.TypeArguments) { var nodes = await GetPartialsForNamespaceAndTypeAsync(arg, includeNamespace : true, solution : solution, cancellationToken : cancellationToken, isInGenericArguments : true).ConfigureAwait(false); genericArguments.Add(GraphNodeId.GetNested(nodes.ToArray())); } partials.Add(GraphNodeId.GetArray( CodeGraphNodeIdName.GenericArgumentsIdentifier, genericArguments.ToArray())); } if (namedType.ContainingType != null) { partials.Add(await GetPartialForTypeAsync(namedType.ContainingType, CodeGraphNodeIdName.ParentType, solution, cancellationToken, hasGenericArguments).ConfigureAwait(false)); } return(GraphNodeId.GetPartial(nodeName, MakeCollectionIfNecessary(false, partials.ToArray()))); } }
private static GraphNodeId GetTopLevelGraphNodeId(string projectPath, string modelId) { string projectFolder = Path.GetDirectoryName(projectPath)?.ToLowerInvariant() ?? string.Empty; var filePath = new Uri(Path.Combine(projectFolder, modelId.ToLowerInvariant()), UriKind.RelativeOrAbsolute); return(GraphNodeId.GetNested( GraphNodeId.GetPartial(CodeGraphNodeIdName.Assembly, new Uri(projectPath, UriKind.RelativeOrAbsolute)), GraphNodeId.GetPartial(CodeGraphNodeIdName.File, filePath))); }
private static object MakeCollectionIfNecessary(bool isHomogeneous, GraphNodeId[] array) { // Place the array of GraphNodeId's into the collection if necessary, so to make them appear in VS Properties Panel if (array.Length > 1) { return(new GraphNodeIdCollection(false, array)); } return(GraphNodeId.GetNested(array)); }
private GraphNodeId GetGraphNodeId(string projectPath, IDependencyNode nodeInfo) { var partialValues = new List <GraphNodeId>(); partialValues.Add(GraphNodeId.GetPartial(CodeGraphNodeIdName.Assembly, new Uri(projectPath, UriKind.RelativeOrAbsolute))); partialValues.Add(GraphNodeId.GetPartial(CodeGraphNodeIdName.File, new Uri(nodeInfo.Id.ToString().ToLowerInvariant(), UriKind.RelativeOrAbsolute))); return(GraphNodeId.GetNested(partialValues.ToArray())); }
private GraphNodeId GetTopLevelGraphNodeId(string projectPath, string modelId) { var partialValues = new List<GraphNodeId> { GraphNodeId.GetPartial(CodeGraphNodeIdName.Assembly, new Uri(projectPath, UriKind.RelativeOrAbsolute)) }; var projectFolder = Path.GetDirectoryName(projectPath)?.ToLowerInvariant() ?? string.Empty; var filePath = new Uri(Path.Combine(projectFolder, modelId.ToLowerInvariant()), UriKind.RelativeOrAbsolute); partialValues.Add(GraphNodeId.GetPartial(CodeGraphNodeIdName.File, filePath)); return GraphNodeId.GetNested(partialValues.ToArray()); }
public static GraphNodeId GetId(this IProjectNode node) { var project = node.As <Project>(); if (project.Kind == EnvDTE.Constants.vsProjectKindUnmodeled) { return(null); } var fileName = GetProjectFileUri(project); if (fileName == null) { return(null); } return(GraphNodeId.GetNested(CodeGraphNodeIdName.Assembly, fileName)); }
public static GraphNode CreateNode(string projectPath, string nodeIdString, IDependencyNode node = null) { var graph = new Graph(); var id = GraphNodeId.GetNested( GraphNodeId.GetPartial(CodeGraphNodeIdName.Assembly, new Uri(projectPath, UriKind.RelativeOrAbsolute)), GraphNodeId.GetPartial(CodeGraphNodeIdName.File, new Uri(nodeIdString, UriKind.RelativeOrAbsolute)) ); var graphNode = graph.Nodes.GetOrCreate(id); if (node != null) { graphNode.SetValue(DependenciesGraphSchema.DependencyNodeProperty, node); } return(graphNode); }
private void CreateNode(IGraphContext context, GraphNode parent, PaketMetadata metadata) { var parentId = parent.GetValue <GraphNodeId>("Id"); var id = GraphNodeId.GetNested( parentId, GraphNodeId.GetPartial(CodeGraphNodeIdName.Member, metadata.Id), GraphNodeId.GetPartial(CodeGraphNodeIdName.Parameter, metadata.VersionString)); var node = context.Graph.Nodes.Get(id); if (node == null) { string label = metadata.Id + " " + metadata.VersionString; node = context.Graph.Nodes.GetOrCreate(id, label, PaketGraphSchema.PaketCategory); node.SetValue(DgmlNodeProperties.ContainsChildren, false); node.SetValue(CodeNodeProperties.SourceLocation, new SourceLocation(new Uri(parentId.GetFileName(), UriKind.Absolute), new Position(PaketGraphSchema.GetDisplayIndex(node), 1))); node.SetValue(DgmlNodeProperties.Icon, GraphIcons.Package); } context.Graph.Links.GetOrCreate(parent, node, null, GraphCommonSchema.Contains); }
private GraphNodeId GetGraphNodeId(string projectPath, IDependencyNode nodeInfo, GraphNode parentNode) { var partialValues = new List <GraphNodeId> { GraphNodeId.GetPartial(CodeGraphNodeIdName.Assembly, new Uri(projectPath, UriKind.RelativeOrAbsolute)), GraphNodeId.GetPartial(CodeGraphNodeIdName.File, new Uri(nodeInfo.Id.ToString().ToLowerInvariant(), UriKind.RelativeOrAbsolute)) }; // to ensure Graph id for node is unique we add a hashcodes for node's parents separated by ';' var parents = parentNode.Id.GetNestedValueByName <string>(CodeGraphNodeIdName.Namespace); if (string.IsNullOrEmpty(parents)) { parents = projectPath.GetHashCode().ToString(); } parents = parents + ";" + nodeInfo.Id.GetHashCode(); partialValues.Add(GraphNodeId.GetPartial(CodeGraphNodeIdName.Namespace, parents)); return(GraphNodeId.GetNested(partialValues.ToArray())); }
public static async Task <GraphNodeId> GetIdForMemberAsync(ISymbol member, Solution solution, CancellationToken cancellationToken) { var partials = new List <GraphNodeId>(); partials.AddRange(await GetPartialsForNamespaceAndTypeAsync(member.ContainingType, true, solution, cancellationToken).ConfigureAwait(false)); var parameters = member.GetParameters(); if (parameters.Any() || member.GetArity() > 0) { var memberPartials = new List <GraphNodeId>(); memberPartials.Add(GraphNodeId.GetPartial(CodeQualifiedName.Name, member.MetadataName)); if (member.GetArity() > 0) { memberPartials.Add(GraphNodeId.GetPartial(CodeGraphNodeIdName.GenericParameterCountIdentifier, member.GetArity().ToString())); } if (parameters.Any()) { var parameterTypeIds = new List <GraphNodeId>(); foreach (var p in parameters) { var parameterIds = await GetPartialsForNamespaceAndTypeAsync(p.Type, true, solution, cancellationToken).ConfigureAwait(false); var nodes = parameterIds.ToList(); if (p.IsRefOrOut()) { nodes.Add(GraphNodeId.GetPartial(CodeGraphNodeIdName.ParamKind, ParamKind.Ref)); } parameterTypeIds.Add(GraphNodeId.GetNested(nodes.ToArray())); } if (member is IMethodSymbol methodSymbol && methodSymbol.MethodKind == MethodKind.Conversion) { // For explicit/implicit conversion operators, we need to include the return type in the method Id, // because there can be several conversion operators with same parameters and only differ by return type. // For example, // // public class Class1 // { // public static explicit (explicit) operator int(Class1 c) { ... } // public static explicit (explicit) operator double(Class1 c) { ... } // } var nodes = await GetPartialsForNamespaceAndTypeAsync(methodSymbol.ReturnType, true, solution, cancellationToken).ConfigureAwait(false); List <GraphNodeId> returnTypePartial = nodes.ToList(); returnTypePartial.Add(GraphNodeId.GetPartial(CodeGraphNodeIdName.ParamKind, Microsoft.VisualStudio.GraphModel.CodeSchema.ParamKind.Return)); GraphNodeId returnCollection = GraphNodeId.GetNested(returnTypePartial.ToArray()); parameterTypeIds.Add(returnCollection); } memberPartials.Add(GraphNodeId.GetArray( CodeGraphNodeIdName.OverloadingParameters, parameterTypeIds.ToArray())); } partials.Add(GraphNodeId.GetPartial( CodeGraphNodeIdName.Member, MakeCollectionIfNecessary(false, memberPartials.ToArray()))); } else { partials.Add(GraphNodeId.GetPartial(CodeGraphNodeIdName.Member, member.MetadataName)); } return(GraphNodeId.GetNested(partials.ToArray())); }
public static GraphNodeId GetId(this IItemNode node) { return(GraphNodeId.GetNested( GraphNodeId.GetPartial(CodeGraphNodeIdName.Assembly, GetProjectFileUri(node.OwningProject.As <Project>())), GraphNodeId.GetPartial(CodeGraphNodeIdName.File, new Uri(node.PhysicalPath, UriKind.RelativeOrAbsolute)))); }