private static IType GetElementType([NotNull] IDeclaredElement element, [NotNull] ISubstitution substitution)
{
if (element is IConstructor || CSharpDeclaredElementUtil.IsDestructor(element))
{
return(null);
}
var typeOwner = element as ITypeOwner;
if (typeOwner != null)
{
return(substitution.Apply(typeOwner.Type));
}
var parametersOwner = element as IParametersOwner;
if (parametersOwner != null)
{
return(substitution.Apply(parametersOwner.ReturnType));
}
var deleg = element as IDelegate;
if (deleg != null)
{
return(substitution.Apply(deleg.InvokeMethod.ReturnType));
}
return(null);
}
public string GetForDeclaredElement([CanBeNull] IDeclaredElement declaredElement)
{
switch (declaredElement)
{
case null:
return(null);
case IMethod method:
if (method.IsPredefined)
{
return(null);
}
return(method.IsExtensionMethod ? ExtensionMethod : Method);
case ISignOperator signOperator:
return(signOperator.IsPredefined ? Operator : UserOperator);
case IConstructor constructor:
return(GetForTypeElement(constructor.GetContainingType()));
case IField field:
return(field.IsField ? Field : Constant);
case ITypeElement typeElement:
return(GetForTypeElement(typeElement));
case IEvent _:
return(Event);
case INamespace _:
return(Namespace);
case IParameter parameter:
return(parameter.IsValueVariable ? Identifier : Parameter);
case ILocalVariable localVariable:
return(localVariable.IsConstant ? Constant : LocalVariable);
case ICSharpAnonymousTypeProperty _:
return(declaredElement is IQueryAnonymousTypeProperty ? LocalVariable : Field);
case ILocalFunction _:
return(LocalFunction);
case IPathDeclaredElement _:
return(Path);
case var _ when CSharpDeclaredElementUtil.IsProperty(declaredElement) || declaredElement.IsCSharpIndexedProperty():
return(Property);
default:
return(Identifier);
}
}
private static bool IsIndexer([NotNull] IDeclaredElement element)
{
var accessor = element as IAccessor;
if (accessor != null)
{
element = accessor.OwnerMember;
}
return(CSharpDeclaredElementUtil.IsIndexer(element) || CSharpDeclaredElementUtil.IsIndexedProperty(element));
}
private static bool ShouldShowParameters([NotNull] IDeclaredElement element)
{
if (CSharpDeclaredElementUtil.IsDestructor(element) || CSharpDeclaredElementUtil.IsProperty(element))
{
return(false);
}
var accessor = element as IAccessor;
return(accessor == null ||
accessor.Kind != AccessorKind.GETTER ||
!CSharpDeclaredElementUtil.IsProperty(accessor.OwnerMember));
}
private void AppendNameWithContainer([NotNull] IDeclaredElement element, [NotNull] ISubstitution substitution, Context context)
{
var typeElement = element as ITypeElement;
if (typeElement != null)
{
AppendTypeElement(typeElement, substitution, QualifierDisplays.Member, context);
return;
}
var ns = element as INamespace;
if (ns != null)
{
AppendNamespace(ns);
return;
}
bool appendedExplicitInterface = false;
if (context.Options.ShowExplicitInterface)
{
var overridableMember = element as IOverridableMember;
if (overridableMember != null && overridableMember.IsExplicitImplementation)
{
IDeclaredType declaredType = CSharpDeclaredElementUtil.InterfaceQualification(overridableMember);
if (declaredType != null)
{
AppendDeclaredType(declaredType, QualifierDisplays.None, context);
AppendText(".", VsHighlightingAttributeIds.Operator);
appendedExplicitInterface = true;
}
}
}
if (!appendedExplicitInterface && (context.Options.ShowQualifiers & QualifierDisplays.Member) != QualifierDisplays.None)
{
var typeMember = element as ITypeMember;
if (typeMember != null)
{
ITypeElement containingTypeElement = typeMember.GetContainingType();
if (containingTypeElement != null)
{
AppendTypeElement(containingTypeElement, substitution, QualifierDisplays.Member, context);
AppendText(".", VsHighlightingAttributeIds.Operator);
}
}
}
AppendName(element);
}
private void AppendName([NotNull] IDeclaredElement element)
{
string highlighterId = _highlighterIdProvider.GetForDeclaredElement(element);
if (CSharpDeclaredElementUtil.IsDestructor(element))
{
ITypeElement containingType = ((IClrDeclaredElement)element).GetContainingType();
if (containingType != null)
{
AppendText("~", _highlighterIdProvider.Operator);
AppendText(containingType.ShortName, highlighterId);
return;
}
}
if (CSharpDeclaredElementUtil.IsIndexer(element))
{
AppendText("this", _highlighterIdProvider.Keyword);
return;
}
if (element is IAnonymousMethod)
{
AppendText("Anonymous method", highlighterId);
return;
}
var conversionOperator = element as IConversionOperator;
if (conversionOperator != null)
{
if (conversionOperator.IsImplicitCast)
{
AppendText("implicit", _highlighterIdProvider.Keyword);
}
else if (conversionOperator.IsExplicitCast)
{
AppendText("explicit", _highlighterIdProvider.Keyword);
}
return;
}
if (element is ISignOperator)
{
string signOperator = GetSignOperator(element.ShortName);
if (!signOperator.IsEmpty())
{
AppendText(signOperator, highlighterId);
return;
}
}
var ns = element as INamespace;
if (ns != null && ns.IsRootNamespace)
{
AppendText("<Root Namespace>", highlighterId);
return;
}
var parameter = element as IParameter;
if (parameter != null && parameter.IsVarArg)
{
AppendText("__arglist", _highlighterIdProvider.Keyword);
return;
}
var constructor = element as IConstructor;
if (constructor != null)
{
ITypeElement containingType = constructor.GetContainingType();
string shortName = containingType?.ShortName ?? constructor.ShortName;
AppendText(FormatShortName(shortName), highlighterId);
return;
}
AppendText(FormatShortName(element.ShortName), highlighterId);
}
private void AppendModifiers([NotNull] IDeclaredElement element)
{
var modifiersOwner = element as IModifiersOwner;
if (modifiersOwner == null || modifiersOwner is IAccessor || CSharpDeclaredElementUtil.IsDestructor(element))
{
return;
}
var builder = new StringBuilder();
if (element is ITypeElement)
{
if (modifiersOwner.IsAbstract && modifiersOwner.IsSealed)
{
builder.Append("static ");
}
else
{
if (modifiersOwner.IsSealed && !(element is IStruct))
{
builder.Append("sealed ");
}
if (modifiersOwner.IsAbstract && !(element is IInterface))
{
builder.Append("abstract ");
}
}
}
else
{
if (modifiersOwner.IsAbstract)
{
builder.Append("abstract ");
}
if (modifiersOwner.IsSealed)
{
builder.Append("sealed ");
}
if (modifiersOwner.IsStatic)
{
builder.Append("static ");
}
}
if (modifiersOwner.IsVirtual)
{
builder.Append("virtual ");
}
if (modifiersOwner.IsOverride)
{
builder.Append("override ");
}
if (modifiersOwner.IsExtern)
{
builder.Append("extern ");
}
if (modifiersOwner.IsReadonly)
{
builder.Append("readonly ");
}
if (modifiersOwner.IsUnsafe)
{
builder.Append("unsafe ");
}
if (modifiersOwner.IsVolatile)
{
builder.Append("volatile ");
}
if (builder.Length > 0)
{
AppendText(builder.ToString(), _highlighterIdProvider.Keyword);
}
}
public static string GetHighlightingAttributeId([CanBeNull] this IDeclaredElement declaredElement, bool useReSharperColors)
{
if (declaredElement is IFunction)
{
var method = declaredElement as IMethod;
if (method != null)
{
if (!useReSharperColors)
{
return(VsHighlightingAttributeIds.Identifier);
}
if (method.IsPredefined)
{
return(null);
}
return(method.IsExtensionMethod
? HighlightingAttributeIds.EXTENSION_METHOD_IDENTIFIER_ATTRIBUTE
: HighlightingAttributeIds.METHOD_IDENTIFIER_ATTRIBUTE);
}
var signOperator = declaredElement as ISignOperator;
if (signOperator != null)
{
return(signOperator.IsPredefined || !useReSharperColors
? VsHighlightingAttributeIds.Operator
: HighlightingAttributeIds.OPERATOR_IDENTIFIER_ATTRIBUTE);
}
var constructor = declaredElement as IConstructor;
if (constructor != null)
{
return(constructor.GetContainingType().GetHighlightingAttributeId(useReSharperColors));
}
}
var field = declaredElement as IField;
if (field != null)
{
if (!useReSharperColors)
{
return(VsHighlightingAttributeIds.Identifier);
}
return(field.IsField
? HighlightingAttributeIds.FIELD_IDENTIFIER_ATTRIBUTE
: HighlightingAttributeIds.CONSTANT_IDENTIFIER_ATTRIBUTE);
}
var typeElement = declaredElement as ITypeElement;
if (typeElement != null)
{
return(typeElement.GetHighlightingAttributeId(useReSharperColors));
}
if (!useReSharperColors)
{
return(VsHighlightingAttributeIds.Identifier);
}
if (CSharpDeclaredElementUtil.IsProperty(declaredElement) || CSharpDeclaredElementUtil.IsIndexedProperty(declaredElement))
{
return(HighlightingAttributeIds.FIELD_IDENTIFIER_ATTRIBUTE);
}
if (declaredElement is IEvent)
{
return(HighlightingAttributeIds.EVENT_IDENTIFIER_ATTRIBUTE);
}
if (declaredElement is INamespace)
{
return(HighlightingAttributeIds.NAMESPACE_IDENTIFIER_ATTRIBUTE);
}
var parameter = declaredElement as IParameter;
if (parameter != null)
{
return(parameter.IsValueVariable ? VsHighlightingAttributeIds.Identifier : HighlightingAttributeIds.PARAMETER_IDENTIFIER_ATTRIBUTE);
}
var localVariable = declaredElement as ILocalVariable;
if (localVariable != null)
{
return(localVariable.IsConstant
? HighlightingAttributeIds.CONSTANT_IDENTIFIER_ATTRIBUTE
: HighlightingAttributeIds.LOCAL_VARIABLE_IDENTIFIER_ATTRIBUTE);
}
if (declaredElement is ICSharpAnonymousTypeProperty)
{
return(declaredElement is IQueryAnonymousTypeProperty
? HighlightingAttributeIds.LOCAL_VARIABLE_IDENTIFIER_ATTRIBUTE
: HighlightingAttributeIds.FIELD_IDENTIFIER_ATTRIBUTE);
}
if (declaredElement is IPathDeclaredElement)
{
return(HighlightingAttributeIds.PATH_IDENTIFIER_ATTRIBUTE);
}
return(null);
}
public static string GetElementKindString([CanBeNull] this IDeclaredElement element)
{
if (element == null)
{
return("unknown");
}
if (element is INamespace)
{
return("namespace");
}
if (element is IClass)
{
return("class");
}
if (element is IInterface)
{
return("interface");
}
if (element is IStruct)
{
return("struct");
}
if (element is IDelegate)
{
return("delegate");
}
if (element is IEnum)
{
return("enum");
}
if (element is ILabel)
{
return("label");
}
if (element is ITypeParameter)
{
return("type parameter");
}
if (element is IAnonymousMethod)
{
return("anonymous method");
}
if (element is IAlias)
{
return("alias");
}
if (element is IQueryRangeVariable || element is IQueryVariable || element is IQueryAnonymousTypeProperty)
{
return("range variable");
}
if (element is IAnonymousTypeProperty)
{
return("property");
}
if (element is IEvent)
{
return("event");
}
if (element is IParameter)
{
return("parameter");
}
if (element is IFunction)
{
if (element is IAccessor)
{
return("accessor");
}
var method = element as IMethod;
if (method != null)
{
if (method.IsExtensionMethod)
{
return("extension");
}
if (CSharpDeclaredElementUtil.IsDestructor(method))
{
return("destructor");
}
return("method");
}
if (element is IConstructor)
{
return("constructor");
}
if (element is IOperator)
{
return("operator");
}
}
var field = element as IField;
if (field != null)
{
if (field.IsField)
{
return("field");
}
if (field.IsConstant)
{
return("constant");
}
if (field.IsEnumMember)
{
return("enum member");
}
}
var property = element as IProperty;
if (property != null)
{
if (CSharpDeclaredElementUtil.IsIndexer(property))
{
return("indexer");
}
if (CSharpDeclaredElementUtil.IsIndexedProperty(property))
{
return("indexed property");
}
return("property");
}
var localVariable = element as ILocalVariable;
if (localVariable != null)
{
return(localVariable.IsConstant ? "local constant" : "local variable");
}
return("unknown");
}
public static bool IsForeachEnumeratorPatternType([NotNull] this ITypeElement typeElement)
{
return(CSharpDeclaredElementUtil.IsForeachEnumeratorPatternType(typeElement));
}
private void AppendName([NotNull] IDeclaredElement element, [CanBeNull] string highlightingAttributeId)
{
if (CSharpDeclaredElementUtil.IsDestructor(element))
{
ITypeElement containingType = ((IClrDeclaredElement)element).GetContainingType();
if (containingType != null)
{
AppendText("~", VsHighlightingAttributeIds.Operator);
AppendText(containingType.ShortName, highlightingAttributeId);
return;
}
}
if (CSharpDeclaredElementUtil.IsIndexer(element))
{
AppendText("this", VsHighlightingAttributeIds.Keyword);
return;
}
if (element is IAnonymousMethod)
{
AppendText("Anonymous method", highlightingAttributeId);
return;
}
var conversionOperator = element as IConversionOperator;
if (conversionOperator != null)
{
if (conversionOperator.IsImplicitCast)
{
AppendText("implicit", VsHighlightingAttributeIds.Keyword);
}
else if (conversionOperator.IsExplicitCast)
{
AppendText("explicit", VsHighlightingAttributeIds.Keyword);
}
return;
}
if (element is ISignOperator)
{
string signOperator = GetSignOperator(element.ShortName);
if (!signOperator.IsEmpty())
{
string attributeId = _options.UseReSharperColors ? HighlightingAttributeIds.OPERATOR_IDENTIFIER_ATTRIBUTE : VsHighlightingAttributeIds.Operator;
AppendText(signOperator, attributeId);
return;
}
}
var ns = element as INamespace;
if (ns != null && ns.IsRootNamespace)
{
AppendText("<Root Namespace>", highlightingAttributeId);
return;
}
var parameter = element as IParameter;
if (parameter != null && parameter.IsVarArg)
{
AppendText("__arglist", VsHighlightingAttributeIds.Keyword);
return;
}
var constructor = element as IConstructor;
if (constructor != null)
{
ITypeElement containingType = constructor.GetContainingType();
string shortName = containingType != null ? containingType.ShortName : constructor.ShortName;
AppendText(FormatShortName(shortName), highlightingAttributeId);
return;
}
AppendText(FormatShortName(element.ShortName), highlightingAttributeId);
}
public static string GetElementKindString(
[CanBeNull] this IDeclaredElement element,
bool useExtensionMethodKind,
bool useAttributeTypeKind,
bool useClassModifiers,
bool useMethodModifiers)
{
if (element == null)
{
return("unknown");
}
var @class = element as IClass;
if (@class != null)
{
string classModifiers = useClassModifiers ? GetClassModifiersDisplay(@class) : null;
string classKind = useAttributeTypeKind && @class.IsAttribute() ? "attribute" : "class";
return(classModifiers + classKind);
}
if (element is INamespace)
{
return("namespace");
}
if (element is IInterface)
{
return("interface");
}
if (element is IStruct)
{
return("struct");
}
if (element is IDelegate)
{
return("delegate");
}
if (element is IEnum)
{
return("enum");
}
if (element is ILabel)
{
return("label");
}
if (element is ITypeParameter)
{
return("type parameter");
}
if (element is IAnonymousMethod)
{
return("anonymous method");
}
if (element is IAlias)
{
return("alias");
}
if (element is IQueryRangeVariable || element is IQueryVariable || element is IQueryAnonymousTypeProperty)
{
return("range variable");
}
if (element is IAnonymousTypeProperty)
{
return("property");
}
if (element is IEvent)
{
return("event");
}
if (element is IParameter)
{
return("parameter");
}
if (element is IFunction)
{
if (element is IAccessor)
{
return("accessor");
}
var method = element as IMethod;
if (method != null)
{
if (useExtensionMethodKind && method.IsExtensionMethod)
{
return("extension");
}
if (CSharpDeclaredElementUtil.IsDestructor(method))
{
return("destructor");
}
return((useMethodModifiers ? GetMethodModifiersDisplay(method) : null) + "method");
}
if (element is IConstructor)
{
return("constructor");
}
if (element is IOperator)
{
return("operator");
}
}
var field = element as IField;
if (field != null)
{
if (field.IsField)
{
return("field");
}
if (field.IsConstant)
{
return("constant");
}
if (field.IsEnumMember)
{
return("enum member");
}
}
var property = element as IProperty;
if (property != null)
{
if (CSharpDeclaredElementUtil.IsIndexer(property))
{
return("indexer");
}
if (property.IsIndexedProperty())
{
return("indexed property");
}
return("property");
}
var localVariable = element as ILocalVariable;
if (localVariable != null)
{
return(localVariable.IsConstant ? "local constant" : "local variable");
}
return("unknown");
}
public override bool Accepts(IDeclaredElement declaredElement, ISubstitution substitution)
{
return(declaredElement is IMethod && !(declaredElement is IAccessor) &&
!CSharpDeclaredElementUtil.IsDestructor(declaredElement));
}
public static IDeclaredElement EliminateDelegateInvokeMethod([NotNull] this IDeclaredElement declaredElement)
{
return(CSharpDeclaredElementUtil.EliminateDelegateInvokeMethod(declaredElement));
}
private static void CheckForeachDeclaration(
[NotNull] IForeachStatement foreachStatement, [NotNull] IHighlightingConsumer consumer)
{
var collection = foreachStatement.Collection;
if (collection == null)
{
return;
}
var collectionType = collection.Type() as IDeclaredType;
if (collectionType == null || collectionType.IsUnknown)
{
return;
}
// no allocations because of compiler support (just like arrays)
if (collectionType.IsString())
{
return;
}
var typeElement = collectionType.GetTypeElement();
if (typeElement == null)
{
return;
}
// search for GetEnumerator() method
var symbolTable = ResolveUtil.GetSymbolTableByTypeElement(
typeElement, SymbolTableMode.FULL, typeElement.Module);
foreach (var symbolInfo in symbolTable.GetSymbolInfos("GetEnumerator"))
{
var method = symbolInfo.GetDeclaredElement() as IMethod;
if (method == null)
{
continue;
}
if (!CSharpDeclaredElementUtil.IsForeachEnumeratorPatternMember(method))
{
continue;
}
// with ref-return
if (method.ReturnType.Classify == TypeClassification.REFERENCE_TYPE)
{
DocumentRange range;
var inToken = collection.GetPreviousMeaningfulToken();
if (inToken != null && inToken.GetTokenType().IsKeyword)
{
range = inToken.GetDocumentRange();
}
else
{
range = collection.GetExpressionRange();
}
consumer.AddHighlighting(
new ObjectAllocationHighlighting(foreachStatement,
"possible enumerator allocation (except iterators or collection with cached enumerator)"),
range);
}
break;
}
}
public string GetForDeclaredElement([CanBeNull] IDeclaredElement declaredElement)
{
if (declaredElement == null)
{
return(null);
}
if (declaredElement is IFunction)
{
var method = declaredElement as IMethod;
if (method != null)
{
if (method.IsPredefined)
{
return(null);
}
return(method.IsExtensionMethod ? ExtensionMethod : Method);
}
var signOperator = declaredElement as ISignOperator;
if (signOperator != null)
{
return(signOperator.IsPredefined ? Operator : UserOperator);
}
var constructor = declaredElement as IConstructor;
if (constructor != null)
{
return(GetForTypeElement(constructor.GetContainingType()));
}
}
var field = declaredElement as IField;
if (field != null)
{
return(field.IsField ? Field : Constant);
}
var typeElement = declaredElement as ITypeElement;
if (typeElement != null)
{
return(GetForTypeElement(typeElement));
}
if (CSharpDeclaredElementUtil.IsProperty(declaredElement) || declaredElement.IsCSharpIndexedProperty())
{
return(Property);
}
if (declaredElement is IEvent)
{
return(Event);
}
if (declaredElement is INamespace)
{
return(Namespace);
}
var parameter = declaredElement as IParameter;
if (parameter != null)
{
return(parameter.IsValueVariable ? Identifier : Parameter);
}
var localVariable = declaredElement as ILocalVariable;
if (localVariable != null)
{
return(localVariable.IsConstant ? Constant : LocalVariable);
}
if (declaredElement is ICSharpAnonymousTypeProperty)
{
return(declaredElement is IQueryAnonymousTypeProperty ? LocalVariable : Field);
}
if (declaredElement is IPathDeclaredElement)
{
return(Path);
}
return(Identifier);
}
