@Override
  protected boolean acceptsForMembersVisibility(
      @NotNull JSPsiElementBase element, @NotNull SinkResolveProcessor resolveProcessor) {
    if (!(element instanceof JSAttributeListOwner)) return true;
    final JSAttributeList attributeList = ((JSAttributeListOwner) element).getAttributeList();

    if (JSResolveUtil.getClassOfContext(place) != JSResolveUtil.getClassOfContext(element)) {
      if (!acceptPrivateMembers) {
        if (attributeList != null
            && attributeList.getAccessType() == JSAttributeList.AccessType.PRIVATE) {
          resolveProcessor.addPossibleCandidateResult(
              element, JSResolveResult.PRIVATE_MEMBER_IS_NOT_ACCESSIBLE);
          return false;
        }
      }

      if (!acceptProtectedMembers) {
        if (attributeList != null
            && attributeList.getAccessType() == JSAttributeList.AccessType.PROTECTED) {
          // we are resolving in context of the class or element within context of the class
          if ((myClassScopeTypeName != null || isParentClassContext(element))) {
            resolveProcessor.addPossibleCandidateResult(
                element, JSResolveResult.PROTECTED_MEMBER_IS_NOT_ACCESSIBLE);
            return false;
          } // if element / context out of class then protected element is ok due to includes
        }
      }
    }

    PsiElement elt = JSResolveUtil.findParent(element);

    if (processStatics) {
      if ((attributeList == null
          || !attributeList.hasModifier(JSAttributeList.ModifierType.STATIC))) {
        if (JSResolveUtil.PROTOTYPE_FIELD_NAME.equals(resolveProcessor.getName())) return true;
        resolveProcessor.addPossibleCandidateResult(
            element, JSResolveResult.INSTANCE_MEMBER_INACCESSIBLE);
        return false;
      }
      if (myTypeName != null
          && elt instanceof JSClass
          && !myTypeName.equals(((JSClass) elt).getQualifiedName())) {
        // static members are inherited in TypeScript classes
        resolveProcessor.addPossibleCandidateResult(
            element, JSResolveResult.STATIC_MEMBER_INACCESSIBLE);
        return false;
      }
    } else if (myClassDeclarationStarted && !allowUnqualifiedStaticsFromInstance) {
      // ActionScript only?
      if (attributeList != null && attributeList.hasModifier(JSAttributeList.ModifierType.STATIC)) {
        boolean referencingClass = false;

        if (place instanceof JSReferenceExpression) {
          JSExpression qualifier = ((JSReferenceExpression) place).getQualifier();
          if (qualifier instanceof JSReferenceExpression) {
            List<JSElement> expressions =
                JSSymbolUtil.calcRefExprValues((JSReferenceExpression) qualifier);
            expressions:
            for (JSElement expression : expressions) {
              if (expression instanceof JSReferenceExpression) {
                for (ResolveResult r : ((JSReferenceExpression) expression).multiResolve(false)) {
                  PsiElement rElement = r.getElement();
                  if (rElement instanceof JSClass) {
                    referencingClass = true;
                    break expressions;
                  }
                }
              }
            }
          }
        }
        if (!referencingClass) {
          resolveProcessor.addPossibleCandidateResult(
              element, JSResolveResult.STATIC_MEMBER_INACCESSIBLE);
          return false;
        }
      }
    }

    if (processActionScriptNotAllowedNsAttributes(element, resolveProcessor, attributeList))
      return false;
    return true;
  }