org.apache.bcel.classfile.FieldOrMethod Java Examples

/**
 * Tests whether the scope of a field or method is compatible
 * with the scope of this check. References for compatible
 * fields or methods should be checked.
 * @param aFieldOrMethod the field or method to check.
 * @return true if the scope of aFieldOrMethod is compatible
 * with the scope of this check.
 */
private boolean equalScope(FieldOrMethod aFieldOrMethod)
{
    if (aFieldOrMethod.isPrivate()) {
        return (mScope == Scope.PRIVATE);
    }
    else if (aFieldOrMethod.isProtected()) {
        return (mScope == Scope.PROTECTED);
    }
    else if (aFieldOrMethod.isPublic()) {
        return (mScope == Scope.PUBLIC);
    }
    else {
        return (mScope == Scope.PACKAGE);
    }
}
 

/**
 * Determines whether the declared scope of a field or method is in
 * a set of scopes.
 * @param aFieldOrMethod the field or method to test.
 * @param aScopes the set of scopes to test against.
 * @return true if the declared scope of aFieldOrMethod is in aScopes.
 */
public static boolean inScope(FieldOrMethod aFieldOrMethod, Set aScopes)
{
    if (aFieldOrMethod.isPrivate()) {
        return (aScopes.contains(Scope.PRIVATE));
    }
    else if (aFieldOrMethod.isProtected()) {
        return (aScopes.contains(Scope.PROTECTED));
    }
    else if (aFieldOrMethod.isPublic()) {
        return (aScopes.contains(Scope.PUBLIC));
    }
    else {
        return (aScopes.contains(Scope.PACKAGE));
    }
}
 

/**
 * Tests whether the scope of a field or method is compatible
 * with the scope of this check. References for compatible
 * fields or methods should be checked.
 * @param aFieldOrMethod the field or method to check.
 * @return true if the scope of aFieldOrMethod is compatible
 * with the scope of this check.
 */
private boolean equalScope(FieldOrMethod aFieldOrMethod)
{
    if (aFieldOrMethod.isPrivate()) {
        return (mScope == Scope.PRIVATE);
    }
    else if (aFieldOrMethod.isProtected()) {
        return (mScope == Scope.PROTECTED);
    }
    else if (aFieldOrMethod.isPublic()) {
        return (mScope == Scope.PUBLIC);
    }
    else {
        return (mScope == Scope.PACKAGE);
    }
}
 

/**
 * Determines whether the declared scope of a field or method is in
 * a set of scopes.
 * @param aFieldOrMethod the field or method to test.
 * @param aScopes the set of scopes to test against.
 * @return true if the declared scope of aFieldOrMethod is in aScopes.
 */
public static boolean inScope(FieldOrMethod aFieldOrMethod, Set aScopes)
{
    if (aFieldOrMethod.isPrivate()) {
        return (aScopes.contains(Scope.PRIVATE));
    }
    else if (aFieldOrMethod.isProtected()) {
        return (aScopes.contains(Scope.PROTECTED));
    }
    else if (aFieldOrMethod.isPublic()) {
        return (aScopes.contains(Scope.PUBLIC));
    }
    else {
        return (aScopes.contains(Scope.PACKAGE));
    }
}
 

/**
 * Checks if the given member is synthetic
 *
 * @param m The member to be checked
 * @return True if the member is synthetic, false otherwise
 * @deprecated You probably don't care for synthetic members, but want to
 *             know if the developer added it (think of lambdas), use
 *             {@link MemberUtils#isUserGenerated(FieldOrMethod)} instead
 */
@Deprecated
public static boolean isSynthetic(FieldOrMethod m) {
    if (m.isSynthetic()) {
        return true;
    }

    for (Attribute a : m.getAttributes()) {
        if (a instanceof Synthetic) {
            return true;
        }
    }
    return false;
}
 

private static boolean internalIsSynthetic(final FieldOrMethod m) {
    if (m.isSynthetic()) {
        return true;
    }

    for (final Attribute a : m.getAttributes()) {
        if (a instanceof Synthetic) {
            return true;
        }
    }

    return false;
}
 

/**
 * Determines whether a class name, and field or method should be ignored.
 * @param aClassName the class name to consider.
 * @param aFieldOrMethod  the field or method to consider.
 * @return true if aClassName, and field or method should be ignored.
 */
protected boolean ignore(String aClassName, FieldOrMethod aFieldOrMethod)
{
    final String fieldOrMethodName = aFieldOrMethod.getName();
    return (!equalScope(aFieldOrMethod)
            || mIgnoreClassNameRegexp.matcher(aClassName).matches()
        || mIgnoreNameRegexp.matcher(fieldOrMethodName).matches());
}
 

/**
 * Returns true if the field or method of a class is accessible from {@code sourceClassName}.
 *
 * @see <a href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-6.html#jls-6.6.1">JLS 6.6.1
 *     Determining Accessibility</a>
 */
private boolean isMemberAccessibleFrom(
    JavaClass targetClass, FieldOrMethod member, String sourceClassName) {
  // The order of these if statements for public, protected, and private are in the same order
  // they
  // appear in JLS 6.6.1
  if (member.isPublic()) {
    return true;
  }
  if (member.isProtected()) {
    if (ClassDumper.classesInSamePackage(targetClass.getClassName(), sourceClassName)) {
      return true;
    }
    try {
      JavaClass sourceClass = classDumper.loadJavaClass(sourceClassName);
      if (ClassDumper.isClassSubClassOf(sourceClass, targetClass)) {
        return true;
      }
    } catch (ClassNotFoundException ex) {
      logger.warning(
          "The source class "
              + sourceClassName
              + " of a reference was not found in the class path when checking accessibility");
      return false;
    }
  }
  if (member.isPrivate()) {
    // Access from within same top-level class is allowed to read private class. However, such
    // cases are already filtered at errorsFromSymbolReferences.
    return false;
  }
  // Default: package private
  if (ClassDumper.classesInSamePackage(targetClass.getClassName(), sourceClassName)) {
    return true;
  }
  return false;
}
 

/**
 * Figure out if a class member (field or method) is synthetic.
 *
 * @param member
 *            a field or method
 * @return true if the member is synthetic
 */
private boolean isSynthetic(FieldOrMethod member) {
    if (BCELUtil.isSynthetic(member)) {
        return true;
    }

    String name = member.getName();

    return name.startsWith("class$") || name.startsWith("access$");
}
 

/**
 * Determines whether a class name, and field or method should be ignored.
 * @param aClassName the class name to consider.
 * @param aFieldOrMethod  the field or method to consider.
 * @return true if aClassName, and field or method should be ignored.
 */
protected boolean ignore(String aClassName, FieldOrMethod aFieldOrMethod)
{
    final String fieldOrMethodName = aFieldOrMethod.getName();
    return (!equalScope(aFieldOrMethod)
            || mIgnoreClassNameRegexp.matcher(aClassName).matches()
        || mIgnoreNameRegexp.matcher(fieldOrMethodName).matches());
}
 

boolean isSynthetic(FieldOrMethod obj) {
    Attribute[] a = obj.getAttributes();
    for (Attribute aA : a) {
        if (aA instanceof Synthetic) {
            return true;
        }
    }
    return false;
}
 

/**
 * Returns the FieldOrMethod.
 * @return the FieldOrMethod.
 */
protected FieldOrMethod getFieldOrMethod()
{
    return mFieldOrMethod;
}
 

private boolean isVisible(FieldOrMethod obj) {
    return (obj.getAccessFlags() & Const.ACC_PUBLIC) != 0 || (obj.getAccessFlags() & Const.ACC_PROTECTED) != 0;
}
 

/**
 * Returns the FieldOrMethod.
 * @return the FieldOrMethod.
 */
protected FieldOrMethod getFieldOrMethod()
{
    return mFieldOrMethod;
}
 

/**
 * Checks if the the given method was user-generated. This takes into
 * account for instance lambda methods, that even though they are marked as
 * "synthetic", they are user-generated, and therefore interesting to
 * analysis.
 *
 * @param m The field or method to check.
 * @return True if the given member is user generated, false otherwise.
 */
public static boolean isUserGenerated(final FieldOrMethod m) {
    return !internalIsSynthetic(m) || (m instanceof Method && couldBeLambda((Method) m));
}
 

/**
 * Constructs a <code>FieldOrMethodDefinition</code> for a Field
 * or a Method.
 * @param aFieldOrMethod the Field or Method
 */
protected FieldOrMethodDefinition(FieldOrMethod aFieldOrMethod)
{
    mFieldOrMethod = aFieldOrMethod;
}
 

/**
 * Constructs a <code>FieldOrMethodDefinition</code> for a Field
 * or a Method.
 * @param aFieldOrMethod the Field or Method
 */
protected FieldOrMethodDefinition(FieldOrMethod aFieldOrMethod)
{
    mFieldOrMethod = aFieldOrMethod;
}