public static bool IsContainerCall(this ITreeNode node, string containerClrTypeName) { var invocationExpression = node as IInvocationExpression; if (invocationExpression == null) { return(false); } var resolve = invocationExpression.InvocationExpressionReference.Resolve().Result; var method = resolve.DeclaredElement as IMethod; if (method == null) { return(false); } ITypeElement containingType = method.GetContainingType(); if (containingType == null) { return(false); } IDeclaredType containerClrType = CreateTypeByClrName(node, containerClrTypeName); return(containingType.IsDescendantOf(containerClrType.GetTypeElement())); }
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 bool IsNinjectBindCall(ITreeNode element) { var invocationExpression = element as IInvocationExpression; if (invocationExpression == null) { return(false); } var resolve = invocationExpression.InvocationExpressionReference.Resolve().Result; var method = resolve.DeclaredElement as IMethod; if (method == null) { return(false); } ITypeElement containingType = method.GetContainingType(); if (containingType == null) { return(false); } if (bindingRootType == null) { bindingRootType = TypeFactory.CreateTypeByCLRName("Ninject.Syntax.IBindingRoot", element.GetPsiModule()); } return(containingType.IsDescendantOf(bindingRootType.GetTypeElement())); }
private bool ownsTypeMatch(IDeclaration declaration) { if (string.IsNullOrEmpty(_isOfType)) { return(true); } if (_isOfTypeType == null) { return(false); } if (declaration is ITypeOwner) { IDeclaredType declaredType = ((ITypeOwner)declaration).Type as IDeclaredType; if (declaredType == null) { return(false); } ITypeElement typeElement = declaredType.GetTypeElement(); if (typeElement == null) { return(false); } return(typeElement.IsDescendantOf(_isOfTypeType)); } else { return(false); } }
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>()); } } } } } } }
static bool IsValidFieldOfType(this IDeclaredElement element, string typeFullName) { IDeclaredType fieldType = element.GetValidatedFieldType(); if (fieldType == null) { return(false); } return(fieldType.GetTypeElement().HasAttributeInstance(new ClrTypeName(typeFullName), false)); }
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 bool IsUnityImplicitType([NotNull] ITypeElement typeElement, [NotNull] IPsiModule module) { foreach (KeyValuePair <string, string> pair in m_unitySettings.UnityClasses.EnumIndexedValues()) { IDeclaredType typeByClrName = TypeFactory.CreateTypeByCLRName(pair.Value, module); ITypeElement unityClass = typeByClrName.GetTypeElement(); if (typeElement.IsDescendantOf(unityClass)) { return(true); } } return(false); }
private bool IsSimple(IType type) { // todo fix for enum bool isEnum = false; IDeclaredType declaredType = type.GetScalarType(); if (declaredType != null) { isEnum = declaredType.GetTypeElement() is IEnum; } return(type.IsSimplePredefined() || isEnum); }
public override bool IsAvailable(IUserDataHolder cache) { using (ReadLockCookie.Create()) { if (Provider.SelectedElement != null) { _superType = TypeHelper.CreateTypeByCLRName(SuperTypeName, Provider.PsiModule, Provider.SelectedElement.GetResolveContext()); if (_superType.GetTypeElement() != null) { _classDeclaration = Provider.SelectedElement.Parent as IClassDeclaration; } } } // !_classDeclaration.IsStatic doesn't work, IsStatic is returns true return _classDeclaration != null && !_classDeclaration.IsStaticEx() && _classDeclaration.SuperTypes.IsEmpty(); }
private static IEnumerable<IComponentRegistration> CreateRegistration(IInvocationExpression invocationExpression, IDeclaredType first, IDeclaredType last) { if (first == null || last == null) { yield break; } ITypeElement fromType = first.GetTypeElement(); ITypeElement toType = last.GetTypeElement(); if (fromType != null && toType != null) { yield return fromType.Equals(toType) ? new ComponentRegistration(invocationExpression, fromType) : new ComponentRegistration(invocationExpression, fromType, toType); } }
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 static IEnumerable <IComponentRegistration> CreateRegistration(IInvocationExpression invocationExpression, IDeclaredType first, IDeclaredType last) { if (first == null || last == null) { yield break; } ITypeElement fromType = first.GetTypeElement(); ITypeElement toType = last.GetTypeElement(); if (fromType != null && toType != null) { yield return(fromType.Equals(toType) ? new ComponentRegistration(invocationExpression, fromType) : new ComponentRegistration(invocationExpression, fromType, toType)); } }
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); }
public IModule GetTargetModule <T>(T element) { var type = element as IType; if (type == null) { return(null); } IDeclaredType declaredType = type.GetScalarType(); if (declaredType != null) { ITypeElement typeElement = declaredType.GetTypeElement(); if (typeElement != null) { return(typeElement.Module.ContainingProjectModule); } } return(null); }
public override IEnumerable <IComponentRegistration> GetComponentRegistrations(ITreeNode registrationRootElement) { IStructuralMatchResult match = Match(registrationRootElement); if (match.Matched) { var invocationExpression = match.GetMatchedElement("bind") as IInvocationExpression; if (invocationExpression == null) { yield break; } IDeclaredType declaredType = GetDeclaredType(invocationExpression); if (declaredType != null) { ITypeElement typeElement = declaredType.GetTypeElement(); if (typeElement != null) { yield return(new ComponentRegistration(registrationRootElement, typeElement)); } } } }
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 StaticTypeWrapper MakeType(IDeclaredType typeHandle) { ITypeParameter typeParameterHandle = typeHandle.GetTypeElement() as ITypeParameter; if (typeParameterHandle != null) return MakeGenericParameterType(typeParameterHandle); return MakeDeclaredType(typeHandle); }
private void ProcessSuperType(XunitTestClassElement classElement, IDeclaredType type) { var @class = type.GetTypeElement() as IClass; if (@class == null) return; foreach (IMethod method in @class.GetMembers().Where(UnitTestElementPsiIdentifier.IsUnitTest)) GetOrCreateMethodElement(classElement, @class, method); }
public static void Initialize(CSharpGeneratorContext context) { _listDeclaredType = TypeFactory.CreateTypeByCLRName(typeof(List <>).FullName, context.PsiModule, context.Anchor.GetResolveContext()); _listTypeElement = _listDeclaredType.GetTypeElement(); }
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); }
private static ITypeName IfTypeIsPredefined(ITypeElement typeElem, IDeclaredType targetElemen, string id) { return(Equals(typeElem, targetElemen.GetTypeElement()) ? Names.Type(id) : null); }