public override void VisitDeclaredType(IDeclaredType declaredType)
{
if (!myTypes.Add(declaredType))
{
return;
}
var typeElement = declaredType.GetTypeElement();
if (typeElement == null)
{
return;
}
var substitution = declaredType.GetSubstitution();
var typeParameters = typeElement.TypeParameters;
if (typeParameters.Count == 0)
{
return;
}
foreach (var typeParameter in typeParameters)
{
substitution[typeParameter].Accept(this);
}
}
private static bool AddEnumerationMembers([NotNull] CSharpCodeCompletionContext context,
[NotNull] GroupedItemsCollector collector,
[NotNull] IDeclaredType qualifierType,
[NotNull] IReferenceExpression referenceExpression)
{
var enumerationType = (IEnum)qualifierType.GetTypeElement().NotNull();
var substitution = qualifierType.GetSubstitution();
var memberValues = new List <Pair <IField, string> >();
var isFlagsEnum = enumerationType.HasAttributeInstance(FlagsAttributeClrName, false);
if (!isFlagsEnum)
{
foreach (var member in enumerationType.EnumMembers)
{
var formattable = member.ConstantValue.Value as IFormattable;
var memberValue = (formattable != null)
? formattable.ToString("D", CultureInfo.InvariantCulture) : string.Empty;
memberValues.Add(Pair.Of(member, memberValue));
}
}
else
{
foreach (var member in enumerationType.EnumMembers)
{
var convertible = member.ConstantValue.Value as IConvertible;
var memberValue = (convertible != null)
? GetBinaryRepresentation(convertible) : string.Empty;
memberValues.Add(Pair.Of(member, memberValue));
}
}
if (memberValues.Count == 0)
{
return(false);
}
// create pointer to . in reference expression
var maxLength = memberValues.Max(x => x.Second.Length);
var reparsedDotRange = referenceExpression.Delimiter.GetTreeTextRange();
var originalDotRange = context.UnterminatedContext.ToOriginalTreeRange(reparsedDotRange);
var file = context.BasicContext.File;
var dotMarker = file.GetDocumentRange(originalDotRange).CreateRangeMarker();
foreach (var member in memberValues)
{
var normalizedValue = member.Second.PadLeft(maxLength, '0');
var value = isFlagsEnum ? normalizedValue : member.Second;
var instance = new DeclaredElementInstance <IField>(member.First, substitution);
var textLookupItem = new EnumMemberLookupItem(dotMarker, instance, normalizedValue, value, isFlagsEnum);
collector.AddSomewhere(textLookupItem);
}
return(true);
}
protected override void Run(IClassDeclaration classDeclaration, ElementProblemAnalyzerData data, IHighlightingConsumer consumer)
{
if (!myIsEnabled.Value)
{
return;
}
var typeElement = classDeclaration.DeclaredElement;
if (typeElement == null || !ZoneConstants.IsZoneClass(typeElement))
{
return;
}
var mark = myMarks.GetMark(typeElement.GetContainingNamespace());
var classes = myMarks.EnumerateClasses(mark).ToList();
// find all base zones
var baseZones = new HashSet <IClass>();
foreach (var cls in classes)
{
foreach (var baseZone in MarksService.EnumerableMarkClasses(cls, true))
{
if (!baseZone.Equals(cls))
{
baseZones.Add(baseZone);
}
}
}
foreach (var typeUsage in classDeclaration.SuperTypeUsageNodes.OfType <IUserDeclaredTypeUsage>())
{
IDeclaredType superType = CSharpTypeFactory.CreateDeclaredType(typeUsage);
var superTypeElement = superType.GetTypeElement();
if (superTypeElement != null)
{
if (ZoneConstants.IsIRequire(superTypeElement as IInterface))
{
var substitution = superType.GetSubstitution();
foreach (var parameter in substitution.Domain)
{
var zoneType = substitution[parameter] as IDeclaredType;
if (zoneType != null)
{
var zoneClass = zoneType.GetTypeElement() as IClass;
if (zoneClass != null && baseZones.Contains(zoneClass))
{
consumer.AddHighlighting(new RedundantDependencySpecificationError(typeUsage), classDeclaration.GetContainingNode <IFile>());
}
}
}
}
}
}
}
public static IClass GetFirstGenericArgument(this IDeclaredElement element)
{
IDeclaredType fieldType = element.GetValidatedFieldType();
if (fieldType == null)
{
return(null);
}
var firstArgument = fieldType.GetSubstitution().Domain.First();
var referencedType = fieldType.GetSubstitution().Apply(firstArgument).GetScalarType();
if (referencedType != null)
{
return(referencedType.GetTypeElement() as IClass);
}
return(null);
}
private static ITypeName GetName(this IDeclaredType type,
IDictionary <DeclaredElementInstance, IName> seenElements)
{
var typeElement = type.GetTypeElement();
// typeElement can be null, for example when resolving the second
// parameter type in the incomplete method declaration
// > public void M(int i, )
return(typeElement == null
? Names.UnknownType
: (ITypeName)typeElement.GetName(type.GetSubstitution(), seenElements));
}
public static IType GetFirstGenericArgumentType([NotNull] this IDeclaredType declared)
{
var substitution = declared.GetSubstitution();
var typeParameter = substitution.Domain.FirstOrDefault();
if (typeParameter == null)
{
return(null);
}
return(substitution.Apply(typeParameter));
}
private void AppendDeclaredType([NotNull] IDeclaredType declaredType, QualifierDisplays expectedQualifierDisplay, Context context)
{
if (declaredType.IsNullable())
{
IType underlyingType = declaredType.GetNullableUnderlyingType();
if (underlyingType != null)
{
AppendTypeWithoutModule(underlyingType, expectedQualifierDisplay, context);
AppendText("?", _highlighterIdProvider.Operator);
return;
}
}
if (declaredType is IDynamicType)
{
AppendText("dynamic", _highlighterIdProvider.Keyword);
return;
}
if (context.Options.UseTypeKeywords)
{
string typeKeyword = CSharpTypeFactory.GetTypeKeyword(declaredType.GetClrName());
if (typeKeyword != null)
{
AppendText(typeKeyword, _highlighterIdProvider.Keyword);
return;
}
}
else if (declaredType.IsVoid())
{
AppendText("void", _highlighterIdProvider.Keyword);
return;
}
ITypeElement typeElement = declaredType.GetTypeElement();
if (typeElement == null || !typeElement.IsValid())
{
PsiLanguageType language = CSharpLanguage.Instance ?? (PsiLanguageType)UnknownLanguage.Instance;
AppendText(declaredType.GetPresentableName(language), null);
}
else
{
AppendTypeElement(typeElement, declaredType.GetSubstitution(), expectedQualifierDisplay, context);
}
}
private void AppendDeclaredType([NotNull] IDeclaredType declaredType, NamespaceDisplays expectedNamespaceDisplay)
{
if (declaredType.IsNullable())
{
IType underlyingType = declaredType.GetNullableUnderlyingType();
if (underlyingType != null)
{
AppendType(underlyingType, expectedNamespaceDisplay);
AppendText("?", VsHighlightingAttributeIds.Operator);
return;
}
}
if (declaredType is IDynamicType)
{
AppendText("dynamic", VsHighlightingAttributeIds.Keyword);
return;
}
if (_options.UseTypeKeywords)
{
string typeKeyword = CSharpTypeFactory.GetTypeKeyword(declaredType.GetClrName());
if (typeKeyword != null)
{
AppendText(typeKeyword, VsHighlightingAttributeIds.Keyword);
return;
}
}
else if (declaredType.IsVoid())
{
AppendText("void", VsHighlightingAttributeIds.Keyword);
return;
}
ITypeElement typeElement = declaredType.GetTypeElement();
if (typeElement == null || !typeElement.IsValid())
{
AppendText(declaredType.GetPresentableName(UnknownLanguage.Instance), null);
return;
}
AppendTypeElement(typeElement, declaredType.GetSubstitution(), expectedNamespaceDisplay);
}
private StaticDeclaredTypeWrapper MakeDeclaredType(IDeclaredType typeHandle)
{
return declaredTypeMemoizer.Memoize(typeHandle, () =>
{
ITypeElement typeElement = typeHandle.GetTypeElement();
if (typeElement == null)
throw new ReflectionResolveException(
String.Format(
"Cannot obtain type element for type '{0}' possibly because its source code is not available.",
typeHandle.GetCLRName()));
return MakeDeclaredType(typeElement, typeHandle.GetSubstitution());
});
}
private static bool AddEnumerationMembers(
[NotNull] CSharpCodeCompletionContext context, [NotNull] IDeclaredType enumerationType, [NotNull] GroupedItemsCollector collector)
{
var enumTypeElement = enumerationType.GetTypeElement() as IEnum;
if (enumTypeElement == null)
{
return(false);
}
var enumSubstitution = enumerationType.GetSubstitution();
var enumMembersWithValues = new List <Pair <DeclaredElementInstance, string> >(); // todo: [R#] List<T1, T2>
var isFlagsEnum = enumTypeElement.HasAttributeInstance(PredefinedType.FLAGS_ATTRIBUTE_CLASS, false);
foreach (var enumMember in enumTypeElement.EnumMembers)
{
var enumValue = enumMember.ConstantValue.Value;
var enumCase = new DeclaredElementInstance(enumMember, enumSubstitution);
if (isFlagsEnum)
{
var convertible = enumValue as IConvertible;
if (convertible != null)
{
enumMembersWithValues.Add(Pair.Of(enumCase, GetBinaryRepresentation(convertible)));
}
}
else
{
var formattable = enumValue as IFormattable;
if (formattable != null)
{
enumMembersWithValues.Add(Pair.Of(enumCase, formattable.ToString("D", CultureInfo.InvariantCulture)));
}
}
}
if (enumMembersWithValues.Count == 0)
{
return(false);
}
var maxLength = enumMembersWithValues.Max(x => x.Second.Length);
var index = 0;
foreach (var enumMember in enumMembersWithValues)
{
var elementInstance = enumMember.First;
var elementValue = isFlagsEnum ? enumMember.Second.PadLeft(maxLength, '0') : enumMember.Second;
var info = new EnumCaseInfo(elementInstance, context, isFlagsEnum, elementValue);
info.Placement.OrderString = "___ENUM_MEMBER_" + index.ToString("D16");
info.Ranges = context.CompletionRanges;
index++;
var lookupItem = LookupItemFactory.CreateLookupItem(info)
.WithPresentation(item =>
{
var presentation = new DeclaredElementPresentation <CSharpDeclaredElementInfo>(item.Info, PresenterStyles.DefaultPresenterStyle);
var caseValue = item.Info.CaseValue;
if (caseValue.Length <= 32)
{
presentation.DisplayTypeName = new RichText("= " + caseValue, EnumValueStyle);
}
return(presentation);
})
.WithMatcher(item => new DeclaredElementMatcher(item.Info, IdentifierMatchingStyle.Default))
.WithBehavior(item => new EnumCaseCheckBehavior(item.Info));
collector.Add(lookupItem);
}
return(true);
}
