public static CodeClassItem MapEnum(EnumDeclarationSyntax member,
ICodeViewUserControl control, SemanticModel semanticModel)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeClassItem>(member, member.Identifier, member.Modifiers, control, semanticModel);
item.Kind = CodeItemKindEnum.Enum;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
item.Parameters = MapMembersToString(member.Members);
item.BorderColor = Colors.DarkGray;
if (TriviaSummaryMapper.HasSummary(member) && SettingsHelper.UseXMLComments)
{
item.Tooltip = TriviaSummaryMapper.Map(member);
}
foreach (var enumMember in member.Members)
{
item.Members.Add(SyntaxMapper.MapMember(enumMember));
}
return(item);
}
public static CodeClassItem MapStruct(VisualBasicSyntax.StructureBlockSyntax member,
ICodeViewUserControl 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.BorderColor = Colors.DarkGray;
if (TriviaSummaryMapper.HasSummary(member) && SettingsHelper.UseXMLComments)
{
item.Tooltip = TriviaSummaryMapper.Map(member);
}
foreach (var structMember in member.Members)
{
item.Members.Add(SyntaxMapper.MapMember(structMember));
}
return(item);
}
public static CodeImplementedInterfaceItem MapImplementedInterface(string name,
ImmutableArray <ISymbol> members, INamedTypeSymbol implementingClass, SyntaxNode currentClass,
ICodeViewUserControl control)
{
var item = new CodeImplementedInterfaceItem
{
Name = name,
FullName = name,
Id = name,
ForegroundColor = Colors.Black,
BorderColor = Colors.DarkGray,
FontSize = Settings.Default.Font.SizeInPoints - 2,
Kind = CodeItemKindEnum.ImplementedInterface,
IsExpanded = true,
Control = control
};
foreach (var member in members)
{
var implementation = implementingClass.FindImplementationForInterfaceMember(member);
if (implementation == null || !implementation.DeclaringSyntaxReferences.Any())
{
continue;
}
// Ignore interface members not directly implemented in the current class
if (implementation.ContainingSymbol != implementingClass)
{
continue;
}
// Ignore interface members not directly implemented in the current file (partial class)
if (implementation.DeclaringSyntaxReferences != null &&
implementation.DeclaringSyntaxReferences.Any() &&
implementation.DeclaringSyntaxReferences.First().SyntaxTree.FilePath != currentClass.SyntaxTree.FilePath)
{
continue;
}
var reference = implementation.DeclaringSyntaxReferences.First();
var declarationSyntax = reference.GetSyntax();
var interfaceMember = SyntaxMapper.MapMember(declarationSyntax as MemberDeclarationSyntax);
if (interfaceMember == null)
{
continue;
}
interfaceMember.OverlayMoniker = KnownMonikers.InterfacePublic;
item.Members.Add(interfaceMember);
}
if (item.Members.Any())
{
item.StartLine = item.Members.Min(i => i.StartLine);
item.EndLine = item.Members.Max(i => i.EndLine);
}
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);
}
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 = SyntaxMapper.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);
}
public static CodeInterfaceItem MapInterface(VisualBasicSyntax.InterfaceBlockSyntax member,
ICodeViewUserControl control, SemanticModel semanticModel, SyntaxTree tree)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeInterfaceItem>(member, member.InterfaceStatement.Identifier,
member.InterfaceStatement.Modifiers, control, semanticModel);
item.Kind = CodeItemKindEnum.Interface;
item.BorderColor = Colors.DarkGray;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
if (TriviaSummaryMapper.HasSummary(member) && SettingsHelper.UseXMLComments)
{
item.Tooltip = TriviaSummaryMapper.Map(member);
}
var regions = RegionMapper.MapRegions(tree, member.Span, control);
foreach (var interfaceMember in member.Members)
{
var memberItem = SyntaxMapper.MapMember(interfaceMember);
if (memberItem != null && !RegionMapper.AddToRegion(regions, memberItem))
{
item.Members.Add(memberItem);
}
}
// Add regions to interface 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 CodeNamespaceItem MapNamespace(NamespaceDeclarationSyntax member,
ICodeViewUserControl control, SemanticModel semanticModel, SyntaxTree tree)
{
if (member == null)
{
return(null);
}
var item = BaseMapper.MapBase <CodeNamespaceItem>(member, member.Name, control, semanticModel);
item.Kind = CodeItemKindEnum.Namespace;
item.Moniker = IconMapper.MapMoniker(item.Kind, item.Access);
item.BorderColor = Colors.DarkGray;
item.IgnoreVisibility = VisibilityHelper.GetIgnoreVisibility(item);
if (TriviaSummaryMapper.HasSummary(member) && SettingsHelper.UseXMLComments)
{
item.Tooltip = TriviaSummaryMapper.Map(member);
}
var regions = RegionMapper.MapRegions(tree, member.Span, control);
foreach (var namespaceMember in member.Members)
{
var memberItem = SyntaxMapper.MapMember(namespaceMember);
if (memberItem != null && !RegionMapper.AddToRegion(regions, memberItem))
{
item.Members.Add(memberItem);
}
}
// Add regions to namespace if they are not present in any children of the namespace
if (regions.Any())
{
foreach (var region in regions)
{
if (FindHelper.FindCodeItem(item.Members, region.Id) == null)
{
item.Members.Add(region);
}
}
}
return(item);
}
public static CodeImplementedInterfaceItem MapImplementedInterface(string name,
ImmutableArray <ISymbol> members, INamedTypeSymbol implementingClass)
{
var item = new CodeImplementedInterfaceItem
{
Name = name,
FullName = name,
Id = name,
Foreground = ColorHelper.ToBrush(Colors.Black),
BorderBrush = ColorHelper.ToBrush(Colors.DarkGray),
FontSize = Settings.Default.Font.SizeInPoints - 2,
Kind = CodeItemKindEnum.ImplementedInterface,
IsExpanded = true
};
foreach (var member in members)
{
var implementation = implementingClass.FindImplementationForInterfaceMember(member);
if (implementation == null || !implementation.DeclaringSyntaxReferences.Any())
{
continue;
}
var reference = implementation.DeclaringSyntaxReferences.First();
var declarationSyntax = reference.GetSyntax();
var interfaceMember = SyntaxMapper.MapMember(declarationSyntax as MemberDeclarationSyntax);
if (interfaceMember == null)
{
continue;
}
interfaceMember.OverlayMoniker = KnownMonikers.InterfacePublic;
item.Members.Add(interfaceMember);
}
if (item.Members.Any())
{
item.StartLine = item.Members.Min(i => i.StartLine);
item.EndLine = item.Members.Max(i => i.EndLine);
}
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);
}
private static CodeItem MapSwitch(SwitchStatementSyntax statement)
{
if (statement == null)
{
return(null);
}
var item = SyntaxMapper.MapBase <CodeClassItem>(statement, statement.Expression.ToString());
item.Name = $"Switch {item.Name}";
item.Kind = CodeItemKindEnum.Switch;
item.Moniker = SyntaxMapper.MapMoniker(item.Kind, item.Access);
item.BorderBrush = SyntaxMapper.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));
}
return(item);
}
public static string Map(CodeItemAccessEnum access, string type, string name, ParameterListSyntax parameters)
{
return(Map(access, type, name, SyntaxMapper.MapParameters(parameters, true)));
}
