protected override bool TryGetItemByName(string name, out EnvDTE.CodeElement element)
{
var node = LookupNode();
foreach (var child in CodeModelService.GetAttributeNodes(node))
{
CodeModelService.GetAttributeNameAndOrdinal(
node,
child,
out var childName,
out var ordinal
);
if (childName == name)
{
element = (EnvDTE.CodeElement)CodeAttribute.Create(
State,
FileCodeModel,
this.ParentElement,
childName,
ordinal
);
return(true);
}
}
element = null;
return(false);
}
internal EnvDTE.CodeParameter AddParameter(EnvDTE.CodeElement parent, SyntaxNode containerNode, string name, object type, object position)
{
var typeSymbol = CodeModelService.GetTypeSymbol(type, this.GetSemanticModel(), containerNode.SpanStart);
var typeName = typeSymbol.GetEscapedFullName();
var parameterNode = CodeModelService.CreateParameterNode(CodeModelService.GetUnescapedName(name), typeName);
var insertionIndex = CodeModelService.PositionVariantToParameterInsertionIndex(position, containerNode, fileCodeModel: this);
var newNode = InsertParameter(containerNode, parameterNode, insertionIndex);
// Since parameters form part of the NodeKey for functions, delegates, and indexers,
// creating a CodeParameter hooked up to the correct parent is a little tricky. After
// the call to InsertParameter, the syntax tree has been updated, but not the NodeKey
// map or the NodeKey in the parent CodeParameter. If we delegate the creation of the
// CodeParameter to CodeModelService.CreateInternalCodeElement, it will attempt to
// look up an element in the NodeKey map based on the new syntax tree. This will fail,
// causing it to create a new, duplicate element for the parent. Later, when we
// reacquire the NodeKeys, the original element will get the proper NodeKey, while the
// duplicate will be updated to a meaningless NodeKey. Since the duplicate is the one
// being used by the CodeParameter, most operations on it will then fail.
// Instead, we need to have the parent passed in to us.
var parentObj = ComAggregate.GetManagedObject <AbstractCodeMember>(parent);
return(CodeParameter.Create(this.State, parentObj, CodeModelService.GetParameterName(newNode)));
}
/*======================= PUBLIC ========================================*/
/************************ Events *****************************************/
/************************ Properties *************************************/
/************************ Construction ***********************************/
/************************ Methods ****************************************/
/************************ Fields *****************************************/
/************************ Static *****************************************/
/*----------------------- GetCodeElement --------------------------------*/
/// <summary>
/// Gets the <see cref="EnvDTE.CodeElement"/> of the text point
/// </summary>
/// <param name="tp"></param>
/// <returns></returns>
public static EnvDTE.CodeElement GetCodeElement(this EnvDTE.TextPoint tp)
{
var scopes = new List <EnvDTE.vsCMElement>()
{
EnvDTE.vsCMElement.vsCMElementFunction,
EnvDTE.vsCMElement.vsCMElementProperty,
EnvDTE.vsCMElement.vsCMElementEnum,
EnvDTE.vsCMElement.vsCMElementClass,
EnvDTE.vsCMElement.vsCMElementInterface,
EnvDTE.vsCMElement.vsCMElementNamespace,
};
EnvDTE.CodeElement retval = null;
foreach (var s in scopes)
{
try
{
var scope = (EnvDTE.vsCMElement)s;
retval = tp.CodeElement[scope];
if (retval != null)
{
break;
}
}
catch {; }
}
return(retval);
} // end of function - GetCodeElement
private static bool FindMethodInCodeElement(EnvDTE.CodeElement codeElement, string fullyQualifiedMethodName,
out EnvDTE.CodeElement discoveredMethodElement)
{
if (codeElement.Kind == EnvDTE.vsCMElement.vsCMElementClass)
{
if (Debugger.IsAttached)
{
WriteToOutputWindow("Processing class: {0}", codeElement.FullName);
}
foreach (EnvDTE.CodeElement classChildCodeElement in codeElement.Children)
{
if (classChildCodeElement.Kind == EnvDTE.vsCMElement.vsCMElementFunction)
{
if (fullyQualifiedMethodName == classChildCodeElement.FullName)
{
discoveredMethodElement = classChildCodeElement;
return(true);
}
}
}
}
foreach (EnvDTE.CodeElement childElement in codeElement.Children)
{
if (FindMethodInCodeElement(childElement, fullyQualifiedMethodName, out discoveredMethodElement))
{
return(true);
}
}
discoveredMethodElement = null;
return(false);
}
protected override bool TryGetItemByName(string name, out EnvDTE.CodeElement element)
{
var node = LookupNode();
// Inherits statements
foreach (var child in CodeModelService.GetInheritsNodes(node))
{
CodeModelService.GetInheritsNamespaceAndOrdinal(node, child, out var childName, out var ordinal);
if (childName == name)
{
element = FileCodeModel.GetOrCreateCodeElement <EnvDTE.CodeElement>(child);
return(true);
}
}
// Implements statements
foreach (var child in CodeModelService.GetImplementsNodes(node))
{
CodeModelService.GetImplementsNamespaceAndOrdinal(node, child, out var childName, out var ordinal);
if (childName == name)
{
element = FileCodeModel.GetOrCreateCodeElement <EnvDTE.CodeElement>(child);
return(true);
}
}
element = null;
return(false);
}
private static bool FindMethodInCodeElement(EnvDTE.CodeElement codeElement, string fullyQualifiedMethodName,
out EnvDTE.CodeElement discoveredMethodElement)
{
if (codeElement.Kind == EnvDTE.vsCMElement.vsCMElementClass)
{
foreach (EnvDTE.CodeElement classChildCodeElement in codeElement.Children)
{
if (classChildCodeElement.Kind == EnvDTE.vsCMElement.vsCMElementFunction)
{
if (fullyQualifiedMethodName == classChildCodeElement.FullName)
{
discoveredMethodElement = classChildCodeElement;
return(true);
}
}
}
}
foreach (EnvDTE.CodeElement childElement in codeElement.Children)
{
if (FindMethodInCodeElement(childElement, fullyQualifiedMethodName, out discoveredMethodElement))
{
return(true);
}
}
discoveredMethodElement = null;
return(false);
}
protected override bool TryGetItemByIndex(int index, out EnvDTE.CodeElement element)
{
var node = LookupNode();
var currentIndex = 0;
// Inherits statements
var inheritsNodes = CodeModelService.GetInheritsNodes(node);
var inheritsNodeCount = inheritsNodes.Count();
if (index < currentIndex + inheritsNodeCount)
{
var child = inheritsNodes.ElementAt(index - currentIndex);
element = FileCodeModel.GetOrCreateCodeElement <EnvDTE.CodeElement>(child);
return(true);
}
currentIndex += inheritsNodeCount;
// Implements statements
var implementsNodes = CodeModelService.GetImplementsNodes(node);
var implementsNodeCount = implementsNodes.Count();
if (index < currentIndex + implementsNodeCount)
{
var child = implementsNodes.ElementAt(index - currentIndex);
element = FileCodeModel.GetOrCreateCodeElement <EnvDTE.CodeElement>(child);
return(true);
}
element = null;
return(false);
}
protected override bool TryGetItemByName(string name, out EnvDTE.CodeElement element)
{
if (name != null)
{
// When searching by name it may or may not be the fully qualified named,
// but we need the fully qualified name for comparison.
var node = LookupNode();
var semanticModel = FileCodeModel.GetSemanticModel();
name = CodeModelService.GetFullyQualifiedName(name, node.SpanStart, semanticModel);
}
foreach (var child in GetBaseTypes())
{
var childName = child.GetEscapedFullName();
if (childName == name)
{
var projectId = FileCodeModel.GetProjectId();
element = CodeModelService.CreateCodeType(this.State, projectId, child);
return(true);
}
}
element = null;
return(false);
}
protected override bool TryGetItemByIndex(int index, out EnvDTE.CodeElement element)
{
var node = LookupNode();
var parentElement = !this.IsRootNamespace ? (AbstractCodeElement)this.Parent : null;
var currentIndex = 0;
// Option statements
var optionNodes = CodeModelService.GetOptionNodes(node);
var optionNodeCount = optionNodes.Count();
if (index < currentIndex + optionNodeCount)
{
var child = optionNodes.ElementAt(index - currentIndex);
element = CreateCodeOptionsStatement(child, node);
return(true);
}
currentIndex += optionNodeCount;
// Imports/using statements
var importNodes = CodeModelService.GetImportNodes(node);
var importNodeCount = importNodes.Count();
if (index < currentIndex + importNodeCount)
{
var child = importNodes.ElementAt(index - currentIndex);
element = CreateCodeImport(child, parentElement);
return(true);
}
currentIndex += importNodeCount;
// Attributes
var attributeNodes = CodeModelService.GetAttributeNodes(node);
var attributeNodeCount = attributeNodes.Count();
if (index < currentIndex + attributeNodeCount)
{
var child = attributeNodes.ElementAt(index - currentIndex);
element = CreateCodeAttribute(child, node, parentElement);
return(true);
}
currentIndex += attributeNodeCount;
// Members
var memberNodes = CodeModelService.GetLogicalSupportedMemberNodes(node);
var memberNodeCount = memberNodes.Count();
if (index < currentIndex + memberNodeCount)
{
var child = memberNodes.ElementAt(index - currentIndex);
element = FileCodeModel.GetOrCreateCodeElement <EnvDTE.CodeElement>(child);
return(true);
}
element = null;
return(false);
}
private static TextSpan CodeElementSpan(EnvDTE.CodeElement element)
{
TextSpan span = new TextSpan();
if (null == element)
{
return(span);
}
span.iStartLine = element.StartPoint.Line;
if (span.iStartLine > 1)
{
span.iStartLine -= 1;
}
span.iStartIndex = element.StartPoint.DisplayColumn;
EnvDTE.TextPoint endPoint = element.EndPoint;
if (null == endPoint)
{
endPoint = element.StartPoint;
}
span.iEndLine = endPoint.Line;
if (span.iEndLine > 1)
{
span.iEndLine -= 1;
}
span.iEndIndex = endPoint.DisplayColumn;
return(span);
}
public void RenameNoUI(EnvDTE.CodeElement element, string newName, bool fPreview, bool fSearchComments, bool fOverloads)
{
// TODO: Support options
var codeElement = ComAggregate.TryGetManagedObject <AbstractCodeElement>(element);
codeElement?.RenameSymbol(newName);
}
protected override bool TryGetItemByName(string name, out EnvDTE.CodeElement element)
{
var node = LookupNode();
var parentElement = !IsRootNamespace
? (AbstractCodeElement)Parent
: null;
// Option statements
foreach (var child in CodeModelService.GetOptionNodes(node))
{
string childName;
int ordinal;
CodeModelService.GetOptionNameAndOrdinal(node, child, out childName, out ordinal);
if (childName == name)
{
element = CodeOptionsStatement.Create(State, FileCodeModel, childName, ordinal);
return(true);
}
}
// Imports/using statements
foreach (var child in CodeModelService.GetImportNodes(node))
{
var childName = CodeModelService.GetImportNamespaceOrType(child);
if (childName == name)
{
element = CodeImport.Create(State, FileCodeModel, parentElement, childName);
return(true);
}
}
// Attributes
foreach (var child in CodeModelService.GetAttributeNodes(node))
{
string childName;
int ordinal;
CodeModelService.GetAttributeNameAndOrdinal(node, child, out childName, out ordinal);
if (childName == name)
{
element = (EnvDTE.CodeElement)CodeAttribute.Create(State, FileCodeModel, parentElement, childName, ordinal);
return(true);
}
}
// Members
foreach (var child in CodeModelService.GetLogicalSupportedMemberNodes(node))
{
var childName = CodeModelService.GetName(child);
if (childName == name)
{
element = FileCodeModel.CreateCodeElement <EnvDTE.CodeElement>(child);
return(true);
}
}
element = null;
return(false);
}
private static TextSpan CodeElementSpan(EnvDTE.CodeElement element)
{
try
{
return(SpanFromTextPoints(element.StartPoint, element.EndPoint));
}
catch
{
return(new TextSpan());
}
}
protected override bool TryGetItemByIndex(int index, out EnvDTE.CodeElement element)
{
if (index < _typeSymbols.Length)
{
element = this.State.CodeModelService.CreateCodeType(this.State, _projectId, _typeSymbols[index]);
return(true);
}
element = null;
return(false);
}
public static CodeElement ToInternalCodeElement(this EnvDTE.CodeElement vsCodeElement)
{
var vsContainingProject = vsCodeElement.ProjectItem?.ContainingProject;
var containingProject = vsContainingProject != null
? new Project(vsContainingProject.FullName)
: (Project?)null;
var codeElementKind = vsCodeElement.Kind.ToInternalKind();
return(new CodeElement(vsCodeElement.FullName, codeElementKind, containingProject));
}
protected override bool TryGetItemByIndex(int index, out EnvDTE.CodeElement element)
{
if (index >= 0 && index < EnumerateOverloads().Length)
{
element = EnumerateOverloads()[index];
return(true);
}
element = null;
return(false);
}
internal void OnCodeElementCreated(SyntaxNodeKey nodeKey, EnvDTE.CodeElement element)
{
// If we're creating an element with the same node key as an element that's already in the table, just remove
// the old element. The old element will continue to function but the new element will replace it in the cache.
if (_codeElementTable.ContainsKey(nodeKey))
{
_codeElementTable.Remove(nodeKey);
}
_codeElementTable.Add(nodeKey, element);
}
internal void GetElementsForCodeModelEvent(
CodeModelEvent codeModelEvent,
out EnvDTE.CodeElement element,
out object parentElement
)
{
parentElement = GetParentElementForCodeModelEvent(codeModelEvent);
if (codeModelEvent.Node == null)
{
element = this.CodeModelService.CreateUnknownRootNamespaceCodeElement(
this.State,
this
);
}
else if (this.CodeModelService.IsParameterNode(codeModelEvent.Node))
{
element = GetParameterElementForCodeModelEvent(codeModelEvent, parentElement);
}
else if (this.CodeModelService.IsAttributeNode(codeModelEvent.Node))
{
element = GetAttributeElementForCodeModelEvent(codeModelEvent, parentElement);
}
else if (this.CodeModelService.IsAttributeArgumentNode(codeModelEvent.Node))
{
element = GetAttributeArgumentElementForCodeModelEvent(
codeModelEvent,
parentElement
);
}
else
{
if (codeModelEvent.Type == CodeModelEventType.Remove)
{
element = this.CodeModelService.CreateUnknownCodeElement(
this.State,
this,
codeModelEvent.Node
);
}
else
{
element = this.GetOrCreateCodeElement <EnvDTE.CodeElement>(codeModelEvent.Node);
}
}
if (element == null)
{
Debug.Fail("We should have created an element for this event!");
}
Debug.Assert(codeModelEvent.Type != CodeModelEventType.Remove || parentElement != null);
}
protected override bool TryGetItemByName(string name, out EnvDTE.CodeElement element)
{
var index = _typeSymbols.IndexOf(t => t.Name == name);
if (index >= 0 && index < _typeSymbols.Length)
{
element = this.State.CodeModelService.CreateCodeType(this.State, _projectId, _typeSymbols[index]);
return(true);
}
element = null;
return(false);
}
protected override bool TryGetItemByIndex(int index, out EnvDTE.CodeElement element)
{
var parts = GetParts();
if (index < parts.Length)
{
element = parts[index];
return(true);
}
element = null;
return(false);
}
/// <summary>
/// Displays the selection dialog box and returns a <seealso cref="CLRType"/> object
/// </summary>
/// <param name="context"></param>
/// <param name="provider"></param>
/// <param name="value"></param>
/// <returns></returns>
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, IServiceProvider provider, object value)
{
object newValue = base.EditValue(context, provider, value);
if (newValue is EnvDTE.CodeElement)
{
EnvDTE.CodeElement codeElement = newValue as EnvDTE.CodeElement;
TCLRType newCLRType = new TCLRType();
newCLRType.Init(codeElement.FullName);
return(newCLRType);
}
return(newValue);
}
protected override bool TryGetItemByIndex(int index, out EnvDTE.CodeElement element)
{
var children = GetChildren();
if (index < children.Length)
{
element = children[index];
return(true);
}
element = null;
return(false);
}
protected override bool TryGetItemByName(string name, out EnvDTE.CodeElement element)
{
foreach (var collection in _collections)
{
if (ErrorHandler.Succeeded(collection.Item(name, out element)))
{
return(true);
}
}
element = null;
return(false);
}
protected override bool TryGetItemByIndex(int index, out EnvDTE.CodeElement element)
{
var parameters = GetParameters();
if (index < parameters.Length)
{
element = (EnvDTE.CodeElement)ExternalCodeParameter.Create(this.State, _projectId, parameters[index], this.ParentElement);
return(true);
}
element = null;
return(false);
}
protected override bool TryGetItemByIndex(int index, out EnvDTE.CodeElement element)
{
var baseTypes = GetBaseTypes();
if (index < baseTypes.Count())
{
var child = baseTypes.ElementAt(index);
var projectId = FileCodeModel.GetProjectId();
element = CodeModelService.CreateCodeType(this.State, projectId, child);
return true;
}
element = null;
return false;
}
protected override bool TryGetItemByName(string name, out EnvDTE.CodeElement element)
{
foreach (var part in GetParts())
{
if (part.Name == name)
{
element = part;
return(true);
}
}
element = null;
return(false);
}
protected override bool TryGetItemByName(string name, out EnvDTE.CodeElement element)
{
var children = GetChildren();
var index = children.IndexOf(e => e.Name == name);
if (index < children.Length)
{
element = children[index];
return(true);
}
element = null;
return(false);
}
protected override bool TryGetItemByName(string name, out EnvDTE.CodeElement element)
{
var parameters = GetParameters();
var index = parameters.IndexOf(p => p.Name == name);
if (index >= 0 && index < parameters.Length)
{
element = (EnvDTE.CodeElement)ExternalCodeParameter.Create(this.State, _projectId, parameters[index], this.ParentElement);
return(true);
}
element = null;
return(false);
}
protected override bool TryGetItemByIndex(int index, out EnvDTE.CodeElement element)
{
var parameters = this.ParentElement.GetParameters();
if (index < parameters.Length)
{
var parameter = parameters[index];
element = (EnvDTE.CodeElement)CodeParameter.Create(this.State, this.ParentElement, parameter.Name);
return(true);
}
element = null;
return(false);
}
public int GetMemberNavigationPoint(string pszClassName, string pszUniqueMemberID, TextSpan[] pSpanNavPoint, out uint pItemID)
{
// Validate the parameters
if (string.IsNullOrEmpty(pszClassName))
{
throw new System.ArgumentNullException("pszClassName");
}
if (string.IsNullOrEmpty(pszUniqueMemberID))
{
throw new System.ArgumentNullException("pszUniqueMemberID");
}
if ((null == pSpanNavPoint) || (0 == pSpanNavPoint.Length))
{
throw new ArgumentNullException("pSpanNavPoint");
}
// Get the implementation class
CodeClassInfo implInfo = ImplementationClass(pszClassName);
if ((null == implInfo) || (null == implInfo.CodeClass))
{
throw new System.ArgumentException("pszClassName");
}
EnvDTE.CodeClass implClass = implInfo.CodeClass;
// Verify that the unique id is valid.
string memberName = MemberNameFromUniqueId(pszUniqueMemberID);
if (string.IsNullOrEmpty(memberName))
{
throw new System.ArgumentException();
}
// Remove the '_' added by the file code model
if (memberName[0] == '_')
{
memberName = memberName.Substring(1);
}
// Get the code element for the member.
EnvDTE.CodeElement member = GetClassMember(implClass, memberName);
if (null == member)
{
throw new System.ArgumentException();
}
// Set the output variables.
pSpanNavPoint[0] = CodeElementSpan(member);
pItemID = implInfo.ItemId;
return(VSConstants.S_OK);
}
