public override int GetHashCode()
{
return(SymbolMarkManager.GetHashCode(this));
}
public int GetHashCode(IBookmarkedSymbol obj)
{
return(SymbolMarkManager.GetHashCode(obj));
}
static IEnumerable <ClassificationTag> GetClassificationType(SyntaxNode node, SemanticModel semanticModel)
{
node = node.Kind() == SyntaxKind.Argument ? ((ArgumentSyntax)node).Expression : node;
//System.Diagnostics.Debug.WriteLine(node.GetType().Name + node.Span.ToString());
var symbol = semanticModel.GetSymbolInfo(node).Symbol;
if (symbol == null)
{
symbol = semanticModel.GetDeclaredSymbol(node);
if (symbol != null)
{
switch (symbol.Kind)
{
case SymbolKind.NamedType:
yield return(symbol.ContainingType != null ? _Classifications.NestedDeclaration : _Classifications.Declaration);
break;
case SymbolKind.Event:
yield return(_Classifications.NestedDeclaration);
break;
case SymbolKind.Method:
if (HighlightOptions.LocalFunctionDeclaration ||
((IMethodSymbol)symbol).MethodKind != MethodKind.LocalFunction)
{
yield return(_Classifications.NestedDeclaration);
}
break;
case SymbolKind.Property:
if (symbol.ContainingType.IsAnonymousType == false)
{
yield return(_Classifications.NestedDeclaration);
}
break;
case SymbolKind.Field:
if (node.IsKind(SyntaxKind.TupleElement))
{
if (((TupleElementSyntax)node).Identifier.IsKind(SyntaxKind.None))
{
symbol = semanticModel.GetTypeInfo(((TupleElementSyntax)node).Type).Type;
}
}
else if (HighlightOptions.NonPrivateField &&
symbol.DeclaredAccessibility >= Accessibility.ProtectedAndInternal &&
symbol.ContainingType.TypeKind != TypeKind.Enum)
{
yield return(_Classifications.NestedDeclaration);
}
break;
case SymbolKind.Local:
yield return(_Classifications.LocalDeclaration);
break;
}
}
else
{
// NOTE: handle alias in using directive
if ((node.Parent as NameEqualsSyntax)?.Parent is UsingDirectiveSyntax)
{
yield return(_Classifications.AliasNamespace);
}
else if (node is AttributeArgumentSyntax)
{
symbol = semanticModel.GetSymbolInfo(((AttributeArgumentSyntax)node).Expression).Symbol;
if (symbol != null && symbol.Kind == SymbolKind.Field && (symbol as IFieldSymbol)?.IsConst == true)
{
yield return(_Classifications.ConstField);
yield return(_Classifications.StaticMember);
}
}
symbol = node.Parent is MemberAccessExpressionSyntax?semanticModel.GetSymbolInfo(node.Parent).CandidateSymbols.FirstOrDefault()
: node.Parent.IsKind(SyntaxKind.Argument) ? semanticModel.GetSymbolInfo(((ArgumentSyntax)node.Parent).Expression).CandidateSymbols.FirstOrDefault()
: node.IsKind(SyntaxKind.SimpleBaseType) ? semanticModel.GetTypeInfo(((SimpleBaseTypeSyntax)node).Type).Type
: node.IsKind(SyntaxKind.TypeConstraint) ? semanticModel.GetTypeInfo(((TypeConstraintSyntax)node).Type).Type
: null;
if (symbol == null)
{
yield break;
}
}
}
switch (symbol.Kind)
{
case SymbolKind.Alias:
case SymbolKind.ArrayType:
case SymbolKind.Assembly:
case SymbolKind.DynamicType:
case SymbolKind.ErrorType:
case SymbolKind.NetModule:
case SymbolKind.PointerType:
case SymbolKind.RangeVariable:
case SymbolKind.Preprocessing:
//case SymbolKind.Discard:
yield break;
case SymbolKind.Label:
yield return(_Classifications.Label);
yield break;
case SymbolKind.TypeParameter:
yield return(_Classifications.TypeParameter);
yield break;
case SymbolKind.Field:
var f = symbol as IFieldSymbol;
yield return(f.IsConst ?
f.ContainingType.TypeKind == TypeKind.Enum ? _Classifications.EnumField
: _Classifications.ConstField
: f.IsReadOnly ? _Classifications.ReadonlyField
: f.IsVolatile ? _Classifications.VolatileField
: _Classifications.Field);
break;
case SymbolKind.Property:
yield return(_Classifications.Property);
break;
case SymbolKind.Event:
yield return(_Classifications.Event);
break;
case SymbolKind.Local:
var localSymbol = symbol as ILocalSymbol;
yield return(localSymbol.IsConst ? _Classifications.ConstField : _Classifications.LocalVariable);
break;
case SymbolKind.Namespace:
yield return(_Classifications.Namespace);
yield break;
case SymbolKind.Parameter:
yield return(_Classifications.Parameter);
break;
case SymbolKind.Method:
var methodSymbol = symbol as IMethodSymbol;
switch (methodSymbol.MethodKind)
{
case MethodKind.Constructor:
yield return
(node is AttributeSyntax || node.Parent is AttributeSyntax || node.Parent?.Parent is AttributeSyntax
? _Classifications.AttributeName
: _Classifications.ConstructorMethod);
break;
case MethodKind.Destructor:
case MethodKind.StaticConstructor:
yield return(_Classifications.ConstructorMethod);
break;
default:
yield return(methodSymbol.IsExtensionMethod ? _Classifications.ExtensionMethod
: methodSymbol.IsExtern ? _Classifications.ExternMethod
: _Classifications.Method);
break;
}
break;
case SymbolKind.NamedType:
break;
default:
yield break;
}
if (SymbolMarkManager.HasBookmark)
{
var markerStyle = SymbolMarkManager.GetSymbolMarkerStyle(symbol);
if (markerStyle != null)
{
yield return(markerStyle);
}
}
if (FormatStore.IdentifySymbolSource && symbol.IsMemberOrType() && symbol.ContainingAssembly != null)
{
yield return(symbol.ContainingAssembly.GetSourceType() == AssemblySource.Metadata
? _Classifications.MetadataSymbol
: _Classifications.UserSymbol);
}
if (symbol.IsStatic)
{
if (symbol.Kind != SymbolKind.Namespace)
{
yield return(_Classifications.StaticMember);
}
}
else if (symbol.IsSealed)
{
if (symbol.Kind == SymbolKind.NamedType && ((ITypeSymbol)symbol).TypeKind != TypeKind.Class)
{
yield break;
}
yield return(_Classifications.SealedMember);
}
else if (symbol.IsOverride)
{
yield return(_Classifications.OverrideMember);
}
else if (symbol.IsVirtual)
{
yield return(_Classifications.VirtualMember);
}
else if (symbol.IsAbstract)
{
yield return(_Classifications.AbstractMember);
}
}