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 BasedOnRegistration(ITreeNode registrationRootElement, ITypeElement basedOnElement, IEnumerable<WithServiceRegistration> withServices)
            : base(registrationRootElement, withServices)
        {
            this.basedOnElement = basedOnElement;

            name = basedOnElement.GetClrName().FullName;
        }

    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 SearchGenericImplementationsRequest(DeclaredElementTypeUsageInfo declaredElement,
                                            ITypeElement originType,
                                            ISearchDomain searchDomain,
                                            IEnumerable<IDeclaredType> originTypeParams)
     : base(declaredElement, originType, searchDomain) {
     _originTypeParams = originTypeParams;
 }

        public override bool IsSatisfiedBy(ITypeElement typeElement)
        {
            if (!types.Contains(typeElement))
                return false;

            return basedOn.IsSatisfiedBy(typeElement);
        }

        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);
        }

 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 true;
            }

            return false;
}

        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 false;
            }

            return withServices.All(registration => registration.IsSatisfiedBy(typeElement));
}

        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 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;
                });
            }