private bool ExtendsTheCallerType(IMethodElement method, ITypeElement callerType, Expression qualifier) { if (method == null || callerType == null) return false; if (method.Parameters.Count == 0) return false; ISourceTreeResolver resolver = ParserServices.SourceTreeResolver; ExpressionCollection arguments = new ExpressionCollection(); arguments.Add(qualifier); method = GenericElementActivator.ActivateMemberIfNeeded(resolver, method, arguments, null, ArgumentsHelper.ResolveArgumentTypes(resolver, arguments)) as IMethodElement; if (method == null) return false; IParameterElement extensionParam = method.Parameters[0] as IParameterElement; if (extensionParam == null) return false; ITypeReferenceExpression typeRef = extensionParam.Type; if (typeRef == null) return false; ITypeElement type = typeRef.GetDeclaration() as ITypeElement; if (type == null) return false; IArrayTypeElement arrayType = callerType as IArrayTypeElement; //if (arrayType != null) //{ // return true; //} //else return ArgumentsHelper.HasParamConversion(resolver, extensionParam, callerType, qualifier, TypeConversionMode.ImplicitConversion); }
private bool IsValidReferenceAndQualifier(LanguageElement activeRerence, out ITypeElement callerType, out Expression qualifier) { qualifier = null; callerType = null; if (!(activeRerence is IHasQualifier)) return false; // should be undeclared.... IElement declaration = activeRerence.GetDeclaration(false); if (declaration != null) return false; qualifier = (activeRerence as IHasQualifier).Qualifier; if (qualifier is MethodReferenceExpression) qualifier = (qualifier as MethodReferenceExpression).Qualifier; if (qualifier == null) return false; callerType = qualifier.Resolve(ParserServices.SourceTreeResolver) as ITypeElement; if (callerType == null) return false; return true; }
public BasedOnRegistration(ITreeNode registrationRootElement, ITypeElement basedOnElement, IEnumerable<WithServiceRegistration> withServices) : base(registrationRootElement, withServices) { this.basedOnElement = basedOnElement; name = basedOnElement.GetClrName().FullName; }
private void SetConstructorsState(ITypeElement typeElement, UsageState state) { foreach (IConstructor constructor in typeElement.Constructors) { collectUsagesStageProcess.SetElementState(constructor, state); } }
public ContextElement CreateContext(ITypeElement type) { if (_cache.Classes.ContainsKey(type)) { return _cache.Classes[type]; } var context = GetOrCreateContextElement(_provider, #if RESHARPER_61 _manager, _psiModuleManager, _cacheManager, #endif _project, _projectEnvoy, type.GetClrName().FullName, _assemblyPath, type.GetSubjectString(), type.GetTags(), type.IsIgnored()); foreach (var child in context.Children) { child.State = UnitTestElementState.Pending; } _cache.Classes.Add(type, context); return context; }
public override bool IsSatisfiedBy(ITypeElement typeElement) { if (!types.Contains(typeElement)) return false; return basedOn.IsSatisfiedBy(typeElement); }
public SearchGenericImplementationsRequest(DeclaredElementTypeUsageInfo declaredElement, ITypeElement originType, ISearchDomain searchDomain, IEnumerable<IDeclaredType> originTypeParams) : base(declaredElement, originType, searchDomain) { _originTypeParams = originTypeParams; }
public ControlFlowInspector([NotNull] ICSharpFunctionDeclaration functionDeclaration, [NotNull] CSharpControlFlowGraf graf, int maxLevel, [NotNull] ITypeElement disposableInterface) : base(functionDeclaration, graf) { _disposableInterface = disposableInterface; _maxLevel = maxLevel; }
public BasedOnRegistration(ITreeNode registrationRootElement, ITypeElement basedOnElement) : base(registrationRootElement) { this.basedOnElement = basedOnElement; name = basedOnElement.GetClrName().FullName; }
/// <summary> /// Is element of type /// </summary> public bool IsElementOfType(ITypeElement DeclaredTypeElement, string type) { if (DeclaredTypeElement == null) return false; if (DeclaredTypeElement.FullName.Replace("`1", "") == type || DeclaredTypeElement.DescendsFrom(type)) return true; return false; } // IsElementOfType(DeclaredTypeElement, type)
public override bool IsSatisfiedBy(ITypeElement typeElement) { if (!typeElement.IsDescendantOf(basedOnElement)) { return false; } return base.IsSatisfiedBy(typeElement);; }
public override bool IsSatisfiedBy(ITypeElement typeElement) { if (!defaultFilter(typeElement)) { return false; } return withServices.All(registration => registration.IsSatisfiedBy(typeElement)); }
public ComponentRegistration(ITreeNode registrationElement, ITypeElement serviceType) : base(registrationElement) { this.serviceType = serviceType; // for some reason, in tests this throws an exception // copying the name to display later in ToString() name = GetDisplayName(serviceType); }
public override bool IsSatisfiedBy(ITypeElement typeElement) { if (defaultFilter(typeElement)) { return true; } return false; }
public override bool IsSatisfiedBy(ITypeElement typeElement) { var attributesOwner = typeElement as IAttributesOwner; if (attributesOwner == null) { return false; } return attributesOwner.HasAttributeInstance(attributeType.GetClrName(), true); }
public override bool IsSatisfiedBy(ITypeElement typeElement) { IModule targetModule = typeElement.Module.ContainingProjectModule; if (targetModule == null) { return false; } return (targetModule.Equals(sourceModule) && basedOn.IsSatisfiedBy(typeElement)); }
public void AddContext(ITypeElement type, ContextElement context) { if (!this._contexts.ContainsKey(type)) { this._contexts.Add(type, context); } else { this._contexts[type] = context; } }
public static bool TryGetTypeElement(string typeName, IPsiModule psiModule, IModuleReferenceResolveContext moduleReferenceResolveContext, out ITypeElement typeElement) { typeElement = null; var typeByClrName = CreateTypeByCLRName(typeName, psiModule, moduleReferenceResolveContext); if (typeByClrName != null) { typeElement = typeByClrName.GetTypeElement(); } return typeElement != null; }
private static string GetDisplayName(ITypeElement element) { IClrTypeName clrName = element.GetClrName(); string fullName = string.Format("{0}.{1}", clrName.GetNamespaceName(), clrName.ShortName); if (element.HasTypeParameters()) { fullName = string.Format("{0}<>", fullName); } return fullName; }
public ControlFlowInspector([NotNull] ICSharpFunctionDeclaration functionDeclaration, [NotNull] CSharpControlFlowGraf graf, [NotNull] ITypeElement disposableInterface) : base(functionDeclaration, graf) { _disposableInterface = disposableInterface; _disposableArguments = GetDisposableArguments(); if (_disposableArguments != null) { _processThis = IsThisDisposable(); _elementDataStorage = InitElementDataStorage(); _psiSourceFile = functionDeclaration.GetSourceFile(); } }
public ClosingTypesRegistration(ITreeNode registrationRootElement, ITypeElement openGenericType) : base(registrationRootElement) { AddFilter(typeElement => { var @interface = openGenericType as IInterface; if ([email protected]()) { return false; } return typeElement.ClosesOver(openGenericType); }); }
public TypesRegistration(ITreeNode registrationRootElement, ITypeElement basedOnElement) : base(registrationRootElement, basedOnElement) { AddFilter(typeElement => { var @class = typeElement as IClass; if (@class == null || @class.IsAbstract || @class.IsStaticClass()) { return false; } return true; }); }
public static Pair<ITypeElement, ITypeMember>? PropertyFromColorElement(ITypeElement qualifierType, IColorElement colorElement, IPsiModule module) { var colorName = UnityNamedColors.GetColorName(colorElement.RGBColor); if (string.IsNullOrEmpty(colorName)) return null; var unityColorType = GetInstance(module).UnityColorType; if (unityColorType == null || !unityColorType.Equals(qualifierType)) return null; var colorProperties = GetStaticColorProperties(unityColorType); var propertyTypeMember = colorProperties.FirstOrDefault(p => p.ShortName == colorName); if (propertyTypeMember == null) return null; return Pair.Of(unityColorType, propertyTypeMember); }
public TypesRegistration(ITreeNode registrationRootElement, ITypeElement basedOnElement) : base(registrationRootElement) { AddFilter(typeElement => { var @class = typeElement as IClass; if (@class != null && @class.IsAbstract) { return false; } return true; }); AddFilter(typeElement => typeElement.IsDescendantOf(basedOnElement)); }
public ContextElement CreateContext(ITypeElement type) { if (_cache.Classes.ContainsKey(type)) { return _cache.Classes[type]; } ContextElement context = new ContextElement(_provider, _project, type.CLRName, _assemblyPath, type.GetTags(), type.IsIgnored()); _cache.Classes.Add(type, context); return context; }
/// <summary> /// Initializes a new instance of the <see cref="ValueAnalysisRefactoring"/> class. /// </summary> /// <param name="typeMemberDeclaration"> /// The type member declaration. /// </param> public ValueAnalysisRefactoring([NotNull] ITypeMemberDeclaration typeMemberDeclaration) { this.typeMemberDeclaration = typeMemberDeclaration; var codeAnnotationsCache = CodeAnnotationsCache.GetInstance(this.Solution); this.notNullTypeElement = codeAnnotationsCache.GetAttributeTypeForElement(this.TypeMemberDeclaration, CodeAnnotationsCache.NotNullAttributeShortName); this.canBeNullTypeElement = codeAnnotationsCache.GetAttributeTypeForElement(this.TypeMemberDeclaration, CodeAnnotationsCache.CanBeNullAttributeShortName); if (this.notNullTypeElement == null || this.canBeNullTypeElement == null) { return; } this.notNullableAttributeClrName = new CLRTypeName(this.notNullTypeElement.CLRName); this.canBeNullAttributeClrName = new CLRTypeName(this.canBeNullTypeElement.CLRName); }
public override bool IsSatisfiedBy(ITypeElement typeElement) { var elementNamespace = typeElement.GetContainingNamespace(); bool isMatch; if (includeSubnamespaces) { isMatch = elementNamespace.QualifiedName == matchedNamespace.QualifiedName || elementNamespace.QualifiedName.StartsWith(matchedNamespace.QualifiedName + ".", StringComparison.OrdinalIgnoreCase); } else { isMatch = elementNamespace.QualifiedName == matchedNamespace.QualifiedName; } return isMatch && base.IsSatisfiedBy(typeElement); }
public TypeInterfaceDescriptor(ITypeElement typeElement, bool instanceOnly) : base(typeElement.GetSolution()) { AutoExpandSingleChild = true; myInstanceOnly = instanceOnly; // We use standard presenter, but emphasize root element using adorements myPresenter = new TypeInterfacePresenter { DrawElementExtensions = true, ShowOccurenceCount = false, PostfixTypeQualification = true }; myPresenter.PresentAdorements += PresentAdorements; // Wrap typeElement with an envoy, so it can survive code changes myTypeElementEnvoy = new DeclaredElementEnvoy<ITypeElement>(typeElement); MakeModel(); }
private static bool IsInsideInitializerToTypeWithSource(CheckContentAvailabilityEventArgs ea) { _TypeElement = null; _ObjectCreationExpression = ea.Element as ObjectCreationExpression; if (_ObjectCreationExpression == null) { _ObjectCreationExpression = ea.Element.GetParent(LanguageElementType.ObjectCreationExpression) as ObjectCreationExpression; if (_ObjectCreationExpression == null) return false; } _InitializerExpression = _ObjectCreationExpression.ObjectInitializer; if (_InitializerExpression == null) return false; _TypeElement = _ObjectCreationExpression.ObjectType.Resolve(ParserServices.SourceTreeResolver) as ITypeElement; if (_TypeElement == null) return false; return !_TypeElement.InReferencedAssembly; }
public override bool IsSatisfiedBy(ITypeElement typeElement) { // todo for now assume that interfaces are not supported if (typeElement is IInterface) { return false; } if (Implementation != null) { if (Implementation.IsGenericInterface()) { return typeElement.IsDescendantOf(Implementation); } return Implementation.Equals(typeElement); } return serviceType.Equals(typeElement); }
//Remove existing, but don't create a new one. protected override IAttribute CreateAttribute(ITypeElement resolvedAttributeType, CSharpElementFactory factory, IPsiModule psiModule) => null;
public bool IsDescendantOfMonoBehaviour([CanBeNull] ITypeElement type) { return(IsDescendantOf(KnownTypes.MonoBehaviour, type)); }
private static bool IsDescendantOfUnityObject([CanBeNull] ITypeElement type) { return(IsDescendantOf(KnownTypes.Object, type)); }
protected FSharpGeneratedPropertyBase(ITypeElement typeElement) =>
protected FSharpGeneratedPropertyFromTypeBase(ITypeElement containingType) =>
public ReflectionMemberNotFoundError(IExpression nameArgument, DeclaredElementType elementType, ITypeElement type, BindingFlags?bindingFlags) { BindingFlags = bindingFlags; _nameArgument = nameArgument; _elementType = elementType; _type = type; }
public GetHashCodeMethod([NotNull] ITypeElement containingType) : base(containingType) { }
public bool IsUnityType([NotNull] ITypeElement type) { return(GetBaseUnityTypes(type).Any()); }
public IEnumerable <UnityType> GetBaseUnityTypes([NotNull] ITypeElement type) { return(myTypes.Value.Where(c => type.IsDescendantOf(c.GetType(type.Module)))); }
private static bool HasTransformTextMethod([NotNull] ITypeElement typeElement) => typeElement .GetAllClassMembers(T4CSharpIntermediateConverterBase.TransformTextMethodName) .SelectNotNull(instance => instance.Member as IMethod) .Any(IsTransformTextMethod);
private static void ChangeAnnotationAttribute(IMethodDeclaration methodDeclaration, string toReplace, ITypeElement replacement) { var toReplaceAttribute = methodDeclaration.Attributes .FirstOrDefault(a => string.Compare(a.Name.QualifiedName, toReplace, StringComparison.InvariantCultureIgnoreCase) == 0); if (toReplaceAttribute != null && replacement != null) { var annotation = CSharpAnnotationsUtil.Annotate(methodDeclaration, replacement); if (annotation.Status == CSharpAnnotationsUtil.Status.AnnotationInserted) { methodDeclaration.RemoveAttribute(toReplaceAttribute); } } }
public bool ReferenceModuleWithType(IPsiModule module, ITypeElement typeToReference) { return(ReferenceModuleImpl(module, typeToReference.Module, typeToReference.GetContainingNamespace().QualifiedName)); }
public bool ReferenceModuleWithType(IPsiModule module, ITypeElement typeToReference, IModuleReferenceResolveContext resolveContext) { return(ReferenceModuleWithType(module, typeToReference)); }
protected GeneratedMethodWithOneParam([NotNull] ITypeElement containingType) : base(containingType) { }
public ToStringMethod([NotNull] ITypeElement containingType) : base(containingType) { }
public EqualsSimpleTypeMethod([NotNull] ITypeElement containingType) : base(containingType) { }
public bool IsUnityColorType([CanBeNull] ITypeElement typeElement) { return((UnityColorType != null && UnityColorType.Equals(typeElement)) || (UnityColor32Type != null && UnityColor32Type.Equals(typeElement))); }
public bool IsDescendantOfScriptableObject([CanBeNull] ITypeElement type) { return(IsDescendantOf(KnownTypes.ScriptableObject, type)); }
public bool IsUnityColorTypeSupportingHSV([CanBeNull] ITypeElement typeElement) { return(UnityColorType != null && UnityColorType.Equals(typeElement)); }
public PreferGenericMethodOverloadQuickFix(PreferGenericMethodOverloadWarning warning) { myInvocationExpression = warning.InvocationMethod; myMethodName = warning.MethodName; myTargetType = warning.TypeElement; }
private static bool EqualSubstitutions([NotNull] ITypeElement referenceOwner, [NotNull] ISubstitution referenceSubstitution, [NotNull] ITypeElement originOwner, [NotNull] ISubstitution originSubstitution) { foreach (var substitution1 in referenceOwner.GetAncestorSubstitution(originOwner)) { var substitution2 = substitution1.Apply(referenceSubstitution); foreach (var typeParameter in substitution2.Domain) { if (originSubstitution.HasInDomain(typeParameter) && !substitution2[typeParameter].IsEquals(originSubstitution[typeParameter])) { return(false); } } } return(true); }
public EqualsObjectWithComparerMethod([NotNull] ITypeElement containingType) : base(containingType) { }
public IEnumerable <UnityType> GetBaseUnityTypes([NotNull] ITypeElement type) { return(myTypes.Value.Where(t => t.SupportsVersion(myUnityVersion.Version) && type.IsDescendantOf(t.GetType(type.Module)))); }
public CompareToSimpleTypeMethod([NotNull] ITypeElement containingType) : base(containingType) { }
public static bool IsDescendantOfUnityEvent([CanBeNull] ITypeElement type) { return(IsDescendantOf(KnownTypes.UnityEvent, type)); }
public CompareToObjectMethod([NotNull] ITypeElement containingMember) : base(containingMember) { }
private static void CheckMethodGroup( [NotNull] IReferenceExpression methodReference, [NotNull] IMethod method, [NotNull] IHighlightingConsumer consumer) { string message = null; var methodType = method.GetContainingType(); if (methodType is IInterface) { message = string.Format("from interface '{0}' method", methodType.ShortName); consumer.AddHighlighting( new SlowDelegateCreationHighlighting(methodReference, message), methodReference.GetExpressionRange()); return; } // there is not lags if method is instance method if (!method.IsStatic && methodReference.QualifierExpression != null && methodReference.QualifierExpression.IsClassifiedAsVariable) { return; } var substitution = methodReference.Reference.Resolve().Result.Substitution; var typeParameters = new JetHashSet <ITypeParameter>(); // collect all the type parameters from the method reference if (!substitution.IsEmpty()) { foreach (var typeParameter in substitution.Domain) { var substitutionType = substitution.Apply(typeParameter); var targs = TypeParametersCollectingVisitor.Collect(substitutionType); typeParameters.UnionWith(targs); } } // get the delegate creation owner type, if member is not static var delegateCreationMember = methodReference.GetContainingTypeMemberDeclaration(); if (delegateCreationMember == null || delegateCreationMember.DeclaredElement == null) { return; } ITypeElement delegateCreationOwnerType = null; if (!delegateCreationMember.DeclaredElement.IsStatic) { delegateCreationOwnerType = delegateCreationMember.DeclaredElement.GetContainingType(); } // look for implicit qualification with the type parameters ITypeElement lastType = null; for (var qualifier = methodReference; qualifier != null; qualifier = qualifier.QualifierExpression as IReferenceExpression) { if (qualifier.IsClassifiedAsVariable) { lastType = null; break; } var resolveResult = qualifier.Reference.Resolve(); lastType = resolveResult.DeclaredElement as ITypeElement; } if (lastType != null) { for (var hidden = lastType.GetContainingType(); hidden != null; hidden = hidden.GetContainingType()) { if (hidden.TypeParameters.Count > 0) { foreach (var typeParameter in hidden.TypeParameters) { typeParameters.Add(typeParameter); } } } } foreach (var parameter in typeParameters) { if (parameter.IsValueType) { continue; } if (delegateCreationOwnerType != null && delegateCreationOwnerType.TypeParameters.Contains(parameter)) { continue; } if (message == null) { message = "method group parametrized with type parameter "; } if (parameter.OwnerType != null) { message += string.Format("'{0}' of type '{1}'", parameter.ShortName, parameter.OwnerType.ShortName); } else if (parameter.OwnerMethod != null) { message += string.Format("'{0}' of method '{1}'", parameter.ShortName, parameter.OwnerMethod.ShortName); } } if (message != null) { consumer.AddHighlighting( new SlowDelegateCreationHighlighting(methodReference, message), methodReference.GetExpressionRange()); } }
public UnionTagProperty([NotNull] ITypeElement typeElement) : base(typeElement) { }
public IEnumerable <ITypeElement> GetImplementedTypes(ITypeElement type) { return(type.DescendantsAndSelf(x => x.GetSuperTypes().Select(y => y.GetTypeElement())).Distinct()); }
public IEnumerable <AssetScriptUsages> GetAssetUsagesFor(IPsiSourceFile sourceFile, ITypeElement declaredElement) { myShellLocks.AssertReadAccessAllowed(); var element = myPointers[sourceFile].GetElement(sourceFile, Id) as AssetUsagesDataElement; if (element == null) { return(Enumerable.Empty <AssetScriptUsages>()); } var guid = AssetUtils.GetGuidFor(myMetaFileGuidCache, declaredElement); if (guid == null) { return(Enumerable.Empty <AssetScriptUsages>()); } // TODO : should we cache result per guid in AssetUsagesDataElement? return(element.EnumerateAssetUsages().Where(t => t.UsageTarget.ExternalAssetGuid == guid)); }