public static CodePropertyItem MapProperty(PropertyDeclarationSyntax member,
CodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodePropertyItem>(member, member.Identifier, member.Modifiers, control, semanticModel);
item.Type = TypeMapper.Map(member.Type);
if (member.AccessorList != null)
{
if (member.AccessorList.Accessors.Any(a => a.Kind() == SyntaxKind.GetAccessorDeclaration))
{
item.Parameters += "get";
}
if (member.AccessorList.Accessors.Any(a => a.Kind() == SyntaxKind.SetAccessorDeclaration))
{
item.Parameters += string.IsNullOrEmpty(item.Parameters) ? "set" : ",set";
}
if (!string.IsNullOrEmpty(item.Parameters))
{
item.Parameters = $" {{{item.Parameters}}}";
}
}
item.Tooltip = TooltipMapper.Map(item.Access, item.Type, item.Name, item.Parameters);
item.Kind = CodeItemKindEnum.Property;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
return(item);
}
/// <summary>
/// Map the active document in the workspace
/// </summary>
/// <param name="activeDocument">active EnvDTE.document</param>
/// <param name="control">CodeNav control that will show the result</param>
/// <param name="workspace">Current Visual Studio workspace</param>
/// <returns>List of found code items</returns>
public static List <CodeItem> MapDocument(EnvDTE.Document activeDocument, CodeViewUserControl control,
VisualStudioWorkspace workspace)
{
_control = control;
if (workspace == null)
{
LogHelper.Log("Error during mapping: Workspace is null");
return(null);
}
try
{
var id = workspace.CurrentSolution.GetDocumentIdsWithFilePath(activeDocument.FullName).FirstOrDefault();
// We can not find the requested document in the current solution,
// Try and map it in a different way
if (id == null)
{
return(MapDocument(activeDocument));
}
var document = workspace.CurrentSolution.GetDocument(id);
return(MapDocument(document));
}
catch (Exception e)
{
LogHelper.Log($"Error during mapping: {e}");
return(null);
}
}
public static CodeItem MapMethod(MethodDeclarationSyntax member, CodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
CodeItem item;
var statementsCodeItems = StatementMapper.MapStatement(member.Body, control, semanticModel);
if (VisibilityHelper.ShouldBeVisible(CodeItemKindEnum.Switch) && statementsCodeItems.Any())
{
// Map method as item containing statements
item = BaseMapper.MapBase <CodeClassItem>(member, member.Identifier, member.Modifiers, control, semanticModel);
((CodeClassItem)item).Members.AddRange(statementsCodeItems);
((CodeClassItem)item).BorderBrush = ColorHelper.ToBrush(Colors.DarkGray);
}
else
{
// Map method as single item
item = BaseMapper.MapBase <CodeFunctionItem>(member, member.Identifier, member.Modifiers, control, semanticModel);
((CodeFunctionItem)item).Type = TypeMapper.Map(member.ReturnType);
((CodeFunctionItem)item).Parameters = ParameterMapper.MapParameters(member.ParameterList);
item.Tooltip = TooltipMapper.Map(item.Access, ((CodeFunctionItem)item).Type, item.Name, member.ParameterList);
}
item.Id = IdMapper.MapId(item.FullName, member.ParameterList);
item.Kind = CodeItemKindEnum.Method;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
return(item);
}
public static CodeClassItem MapClass(VisualBasicSyntax.TypeBlockSyntax member,
CodeViewUserControl control, SemanticModel semanticModel, SyntaxTree tree)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeClassItem>(member, member.BlockStatement.Identifier,
member.BlockStatement.Modifiers, control, semanticModel);
item.Kind = CodeItemKindEnum.Class;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
item.Parameters = MapInheritance(member);
item.BorderBrush = ColorHelper.ToBrush(Colors.DarkGray);
item.Tooltip = TooltipMapper.Map(item.Access, string.Empty, item.Name, item.Parameters);
var regions = RegionMapper.MapRegions(tree, member.Span);
var implementedInterfaces = InterfaceMapper.MapImplementedInterfaces(member, semanticModel);
foreach (var classMember in member.Members)
{
var memberItem = SyntaxMapper.MapMember(classMember);
if (memberItem != null && !InterfaceMapper.IsPartOfImplementedInterface(implementedInterfaces, memberItem) &&
!RegionMapper.AddToRegion(regions, memberItem))
{
item.Members.Add(memberItem);
}
}
// Add implemented interfaces to class or region if they have a interface member inside them
if (implementedInterfaces.Any())
{
foreach (var interfaceItem in implementedInterfaces)
{
if (interfaceItem.Members.Any())
{
if (!RegionMapper.AddToRegion(regions, interfaceItem))
{
item.Members.Add(interfaceItem);
}
}
}
}
// Add regions to class if they have a region member inside them
if (regions.Any())
{
foreach (var region in regions)
{
if (region.Members.Any())
{
item.Members.Add(region);
}
}
}
return(item);
}
public static CodeItem MapDelegate(VisualBasicSyntax.DelegateStatementSyntax member,
CodeViewUserControl control, SemanticModel semanticModel)
{
var item = BaseMapper.MapBase <CodeItem>(member, member.Identifier, member.Modifiers, control, semanticModel);
item.Kind = CodeItemKindEnum.Delegate;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
return(item);
}
public static CodeItem MapField(VisualBasicSyntax.FieldDeclarationSyntax member,
CodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
return(MapField(member, member.Declarators.First().Names.First().Identifier, member.Modifiers, control, semanticModel));
}
public static CodeItem MapEvent(EventFieldDeclarationSyntax member,
CodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeItem>(member, member.Declaration.Variables.First().Identifier,
member.Modifiers, control, semanticModel);
item.Kind = CodeItemKindEnum.Event;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
return(item);
}
public static CodeItem MapEvent(VisualBasicSyntax.EventBlockSyntax member,
CodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeItem>(member, member.EventStatement.Identifier,
member.EventStatement.Modifiers, control, semanticModel);
item.Kind = CodeItemKindEnum.Event;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
return(item);
}
public static CodeItem MapEnumMember(VisualBasicSyntax.EnumMemberDeclarationSyntax member,
CodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeItem>(member, member.Identifier, control, semanticModel);
item.Kind = CodeItemKindEnum.EnumMember;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
return(item);
}
/// <summary>
/// Map the active document in the workspace
/// </summary>
/// <param name="activeDocument">active EnvDTE.document</param>
/// <param name="control">CodeNav control that will show the result</param>
/// <param name="workspace">Current Visual Studio workspace</param>
/// <returns>List of found code items</returns>
public static List <CodeItem> MapDocument(EnvDTE.Document activeDocument, CodeViewUserControl control,
VisualStudioWorkspace workspace)
{
_control = control;
if (workspace == null)
{
LogHelper.Log("Error during mapping: Workspace is null");
return(null);
}
try
{
var filePath = DocumentHelper.GetFullName(activeDocument);
if (string.IsNullOrEmpty(filePath))
{
return(MapDocument(activeDocument));
}
var id = workspace.CurrentSolution.GetDocumentIdsWithFilePath(filePath).FirstOrDefault();
// We can not find the requested document in the current solution,
// Try and map it in a different way
if (id == null)
{
return(MapDocument(activeDocument));
}
var document = workspace.CurrentSolution.GetDocument(id);
return(MapDocument(document));
}
catch (ArgumentException e)
{
if (!e.Message.Contains("DeclarationSyntax"))
{
LogHelper.Log("Error during mapping", e, DocumentHelper.GetText(activeDocument), activeDocument.Language);
}
return(null);
}
catch (Exception e)
{
LogHelper.Log($"Error during mapping: {e}");
LogHelper.Log("Error during mapping", e, DocumentHelper.GetText(activeDocument), activeDocument.Language);
return(null);
}
}
public static CodeItem MapStatement(StatementSyntax statement, CodeViewUserControl control, SemanticModel semanticModel)
{
if (statement == null)
{
return(null);
}
switch (statement.Kind())
{
case SyntaxKind.SwitchStatement:
return(MapSwitch(statement as SwitchStatementSyntax, control, semanticModel));
default:
return(null);
}
}
/// <summary>
/// Map the individual cases within a switch statement
/// </summary>
/// <param name="section"></param>
/// <param name="control"></param>
/// <param name="semanticModel"></param>
/// <returns></returns>
private static CodeItem MapSwitchSection(SwitchSectionSyntax section, CodeViewUserControl control, SemanticModel semanticModel)
{
if (section == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodePropertyItem>(section, section.Labels.First().ToString(), control, semanticModel);
item.Tooltip = TooltipMapper.Map(item.Access, item.Type, item.Name, string.Empty);
item.Id = IdMapper.MapId(item.FullName, null);
item.Kind = CodeItemKindEnum.SwitchSection;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
return(item);
}
public static CodeNamespaceItem MapNamespace(NamespaceDeclarationSyntax member,
CodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeNamespaceItem>(member, member.Name, control, semanticModel);
item.Kind = CodeItemKindEnum.Namespace;
foreach (var namespaceMember in member.Members)
{
item.Members.Add(SyntaxMapper.MapMember(namespaceMember));
}
return(item);
}
private static CodeItem MapField(SyntaxNode member, SyntaxToken identifier, SyntaxTokenList modifiers,
CodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeItem>(member, identifier, modifiers, control, semanticModel);
item.Kind = IsConstant(modifiers)
? CodeItemKindEnum.Constant
: CodeItemKindEnum.Variable;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
return(item);
}
public static CodeItem MapConstructor(ConstructorDeclarationSyntax member, CodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeFunctionItem>(member, member.Identifier, member.Modifiers, control, semanticModel);
item.Parameters = ParameterMapper.MapParameters(member.ParameterList);
item.Tooltip = TooltipMapper.Map(item.Access, item.Type, item.Name, member.ParameterList);
item.Id = IdMapper.MapId(member.Identifier, member.ParameterList);
item.Kind = CodeItemKindEnum.Constructor;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
item.OverlayMoniker = KnownMonikers.Add;
return(item);
}
public static CodeItem MapMethod(VisualBasicSyntax.MethodBlockSyntax member, CodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
CodeItem item;
var statementsCodeItems = StatementMapper.MapStatement(member.Statements, control, semanticModel);
if (VisibilityHelper.ShouldBeVisible(CodeItemKindEnum.Switch) && statementsCodeItems.Any())
{
// Map method as item containing statements
item = BaseMapper.MapBase <CodeClassItem>(member, member.SubOrFunctionStatement.Identifier,
member.SubOrFunctionStatement.Modifiers, control, semanticModel);
((CodeClassItem)item).Members.AddRange(statementsCodeItems);
((CodeClassItem)item).BorderBrush = ColorHelper.ToBrush(Colors.DarkGray);
}
else
{
// Map method as single item
item = BaseMapper.MapBase <CodeFunctionItem>(member, member.SubOrFunctionStatement.Identifier,
member.SubOrFunctionStatement.Modifiers, control, semanticModel);
var symbol = semanticModel.GetDeclaredSymbol(member) as IMethodSymbol;
((CodeFunctionItem)item).Type = TypeMapper.Map(symbol?.ReturnType);
((CodeFunctionItem)item).Parameters = ParameterMapper.MapParameters(member.SubOrFunctionStatement.ParameterList, semanticModel);
item.Tooltip = TooltipMapper.Map(item.Access, ((CodeFunctionItem)item).Type, item.Name,
member.SubOrFunctionStatement.ParameterList, semanticModel);
}
item.Id = IdMapper.MapId(item.FullName, member.SubOrFunctionStatement.ParameterList, semanticModel);
item.Kind = CodeItemKindEnum.Method;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
if (TriviaSummaryMapper.HasSummary(member) && SettingsHelper.UseXMLComments)
{
item.Tooltip = TriviaSummaryMapper.Map(member);
}
return(item);
}
public static CodeInterfaceItem MapInterface(InterfaceDeclarationSyntax member,
CodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeInterfaceItem>(member, member.Identifier, member.Modifiers, control, semanticModel);
item.Kind = CodeItemKindEnum.Interface;
item.BorderBrush = ColorHelper.ToBrush(Colors.DarkGray);
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
foreach (var interfaceMember in member.Members)
{
item.Members.Add(SyntaxMapper.MapMember(interfaceMember));
}
return(item);
}
public static CodeClassItem MapStruct(VisualBasicSyntax.StructureBlockSyntax member,
CodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeClassItem>(member, member.StructureStatement.Identifier,
member.StructureStatement.Modifiers, control, semanticModel);
item.Kind = CodeItemKindEnum.Struct;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
item.BorderBrush = ColorHelper.ToBrush(Colors.DarkGray);
foreach (var structMember in member.Members)
{
item.Members.Add(SyntaxMapper.MapMember(structMember));
}
return(item);
}
public static CodePropertyItem MapProperty(VisualBasicSyntax.PropertyBlockSyntax member,
CodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodePropertyItem>(member, member.PropertyStatement.Identifier,
member.PropertyStatement.Modifiers, control, semanticModel);
var symbol = semanticModel.GetDeclaredSymbol(member) as IPropertySymbol;
item.Type = TypeMapper.Map(symbol.Type);
if (member.Accessors != null)
{
if (member.Accessors.Any(a => a.Kind() == VisualBasic.SyntaxKind.GetAccessorBlock))
{
item.Parameters += "get";
}
if (member.Accessors.Any(a => a.Kind() == VisualBasic.SyntaxKind.SetAccessorBlock))
{
item.Parameters += string.IsNullOrEmpty(item.Parameters) ? "set" : ",set";
}
if (!string.IsNullOrEmpty(item.Parameters))
{
item.Parameters = $" {{{item.Parameters}}}";
}
}
item.Tooltip = TooltipMapper.Map(item.Access, item.Type, item.Name, item.Parameters);
item.Kind = CodeItemKindEnum.Property;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
return(item);
}
/// <summary>
/// Map a switch statement
/// </summary>
/// <param name="statement"></param>
/// <param name="control"></param>
/// <param name="semanticModel"></param>
/// <returns></returns>
private static CodeItem MapSwitch(SwitchStatementSyntax statement, CodeViewUserControl control, SemanticModel semanticModel)
{
if (statement == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeClassItem>(statement, statement.Expression.ToString(), control, semanticModel);
item.Name = $"Switch {item.Name}";
item.Kind = CodeItemKindEnum.Switch;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
item.BorderBrush = ColorHelper.CreateSolidColorBrush(Colors.DarkGray);
item.Tooltip = TooltipMapper.Map(item.Access, string.Empty, item.Name, item.Parameters);
// Map switch cases
foreach (var section in statement.Sections)
{
item.Members.Add(MapSwitchSection(section, control, semanticModel));
}
return(item);
}
public static List <CodeItem> MapStatement(StatementSyntax statement, CodeViewUserControl control, SemanticModel semanticModel)
{
if (statement == null)
{
return(new List <CodeItem>());
}
switch (statement.Kind())
{
case SyntaxKind.SwitchStatement:
return(new List <CodeItem> {
MapSwitch(statement as SwitchStatementSyntax, control, semanticModel)
});
case SyntaxKind.Block:
return(MapStatements((statement as BlockSyntax).Statements, control, semanticModel));
case SyntaxKind.TryStatement:
return(MapStatement((statement as TryStatementSyntax).Block, control, semanticModel));
default:
return(new List <CodeItem>());
}
}
private static T MapBase <T>(SyntaxNode source, string name, SyntaxTokenList modifiers, CodeViewUserControl control, SemanticModel semanticModel) where T : CodeItem
{
var element = Activator.CreateInstance <T>();
element.Name = name;
element.FullName = GetFullName(source, name, semanticModel);
element.Id = element.FullName;
element.Tooltip = name;
element.StartLine = GetStartLine(source);
element.StartLinePosition = GetStartLinePosition(source);
element.EndLine = GetEndLine(source);
element.EndLinePosition = GetEndLinePosition(source);
element.Foreground = ColorHelper.ToBrush(Colors.Black);
element.Access = MapAccess(modifiers, source);
element.FontSize = Settings.Default.Font.SizeInPoints;
element.ParameterFontSize = Settings.Default.Font.SizeInPoints - 1;
element.FontFamily = new FontFamily(Settings.Default.Font.FontFamily.Name);
element.FontStyle = FontStyleMapper.Map(Settings.Default.Font.Style);
element.Control = control;
return(element);
}
public static T MapBase <T>(SyntaxNode source, SyntaxToken identifier, CodeViewUserControl control, SemanticModel semanticModel) where T : CodeItem
{
return(MapBase <T>(source, identifier.Text, new SyntaxTokenList(), control, semanticModel));
}
public static List <CodeItem> MapStatements(SyntaxList <StatementSyntax> statements, CodeViewUserControl control, SemanticModel semanticModel)
{
var list = new List <CodeItem>();
if (!statements.Any())
{
return(list);
}
foreach (var statement in statements)
{
list.AddRange(MapStatement(statement, control, semanticModel));
}
return(list);
}
public static List <CodeItem> MapStatement(BlockSyntax statement, CodeViewUserControl control, SemanticModel semanticModel) => MapStatement(statement as StatementSyntax, control, semanticModel);
public static T MapBase <T>(SyntaxNode source, string name, CodeViewUserControl control, SemanticModel semanticModel) where T : CodeItem
{
return(MapBase <T>(source, name, new SyntaxTokenList(), control, semanticModel));
}
/// <summary>
/// Initializes a new instance of the <see cref="CodeNavToolWindow"/> class.
/// </summary>
public CodeNavToolWindow() : base(null)
{
Caption = "CodeNav";
_control = new CodeViewUserControl(null);
Content = _control;
}
public static T MapBase <T>(SyntaxNode source, VisualBasicSyntax.NameSyntax name, CodeViewUserControl control, SemanticModel semanticModel) where T : CodeItem
{
return(MapBase <T>(source, name.ToString(), new SyntaxTokenList(), control, semanticModel));
}
public static List <CodeItem> MapStatement(VisualBasicSyntax.StatementSyntax statement, CodeViewUserControl control, SemanticModel semanticModel)
{
if (statement == null)
{
return(new List <CodeItem>());
}
switch (statement.Kind())
{
case VisualBasic.SyntaxKind.SelectBlock:
return(new List <CodeItem> {
MapSwitch(statement as VisualBasicSyntax.SelectBlockSyntax, control, semanticModel)
});
case VisualBasic.SyntaxKind.TryStatement:
return(MapStatement((statement as VisualBasicSyntax.TryBlockSyntax), control, semanticModel));
default:
return(new List <CodeItem>());
}
}
