Java XMethod类代码示例

import edu.umd.cs.findbugs.ba.XMethod; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private boolean checkNonSuper(XMethod m, Set<XMethod> others) {
    if (m.isStatic())
        return false;
    if (m.getName().startsWith("<init>") || m.getName().startsWith("<clinit>"))
        return false;
    for (XMethod m2 : others) {
        if (confusingMethodNamesWrongCapitalization(m, m2)) {
            XMethod mm1 = m;
            XMethod mm2 = m2;
            if (m.compareTo(m2) < 0) {
                mm1 = m;
                mm2 = m2;
            } else {
                mm1 = m2;
                mm2 = m;
            }
            bugReporter.reportBug(new BugInstance(this, "NM_CONFUSING", LOW_PRIORITY).addClass(mm1.getClassName())
                    .addMethod(mm1).addClass(mm2.getClassName()).addMethod(mm2));
            return true;
        }
    }
    return false;
}
 

import edu.umd.cs.findbugs.ba.XMethod; //导入依赖的package包/类
@Override
public void visit(Code code) {
    if (getMethod().isStatic() || getMethod().isPrivate())
        return;
    XMethod overrides = Lookup.findSuperImplementorAsXMethod(getThisClass(), getMethodName(), getMethodSig(), bugReporter);

    if (overrides == null)
        return;
    AnnotationValue annotation = overrides.getAnnotation(mustOverrideAnnotation);
    if (annotation == null)
        return;
    sawCallToSuper = false;
    super.visit(code);
    if (!sawCallToSuper)
        bugReporter.reportBug(new BugInstance(this, "TESTING", NORMAL_PRIORITY).addClassAndMethod(this).addString(
                "Method must invoke override method in superclass"));
}
 

import edu.umd.cs.findbugs.ba.XMethod; //导入依赖的package包/类
@Override
public void visit(Code m) {
    applicableApplications = new HashSet<TypeQualifierValue<?>>();
    XMethod xMethod = getXMethod();

    // Find the direct annotations on this method
    updateApplicableAnnotations(xMethod);

    // Find direct annotations on called methods and loaded fields
    super.visit(m);

    if (applicableApplications.size() > 0) {
        qualifiers.setDirectlyRelevantTypeQualifiers(getMethodDescriptor(), new ArrayList<TypeQualifierValue<?>>(
                applicableApplications));
    }
}
 

import edu.umd.cs.findbugs.ba.XMethod; //导入依赖的package包/类
private void emitSourceWarning(String bugType, XMethod xMethod, TypeQualifierValue typeQualifierValue,
        FlowValue backwardsFlowValue, TypeQualifierValueSet backwardsFact, SourceSinkInfo source, ValueNumber vn,
        Location location) {

    BugInstance warning = new BugInstance(this, bugType, Priorities.NORMAL_PRIORITY).addClassAndMethod(xMethod);
    annotateWarningWithTypeQualifier(warning, typeQualifierValue);

    annotateWarningWithSourceSinkInfo(warning, xMethod, vn, source);

    Set<? extends SourceSinkInfo> sinkSet = (backwardsFlowValue == FlowValue.NEVER) ? backwardsFact.getWhereNever(vn) : backwardsFact
            .getWhereAlways(vn);
    for (SourceSinkInfo sink : sinkSet) {
        annotateWarningWithSourceSinkInfo(warning, xMethod, vn, sink);
    }

    bugReporter.reportBug(warning);
}
 

import edu.umd.cs.findbugs.ba.XMethod; //导入依赖的package包/类
/**
 * @param lhsSig
 * @param rhsSig
 * @param targets
 * @return
 */
private boolean checkForWeirdEquals(String lhsSig, String rhsSig, Set<XMethod> targets) {
    boolean allOk = false;
    try {
        ClassSummary classSummary = AnalysisContext.currentAnalysisContext().getClassSummary();

        ClassDescriptor expectedClassDescriptor = DescriptorFactory.createClassDescriptorFromSignature(lhsSig);
        ClassDescriptor actualClassDescriptor = DescriptorFactory.createClassDescriptorFromSignature(rhsSig);

        targets.addAll(Hierarchy2.resolveVirtualMethodCallTargets(expectedClassDescriptor, "equals", "(Ljava/lang/Object;)Z",
                false, false));
        allOk = targets.size() > 0;
        for (XMethod m2 : targets)
            if (!classSummary.mightBeEqualTo(m2.getClassDescriptor(), actualClassDescriptor))
                allOk = false;

    } catch (ClassNotFoundException e) {
        AnalysisContext.reportMissingClass(e);
    }
    return allOk;
}
 

import edu.umd.cs.findbugs.ba.XMethod; //导入依赖的package包/类
public void addMethodAnnotation(String cName, String mName, String sig, boolean isStatic, NullnessAnnotation annotation) {
    if (DEBUG) {
        System.out.println("addMethodAnnotation: annotate " + cName + "." + mName + " with " + annotation);
    }
    XMethod xmethod = getXMethod(cName, mName, sig, isStatic);
    if (xmethod == null)
        return;
    // Get JSR-305 nullness annotation type
    ClassDescriptor nullnessAnnotationType = getNullnessAnnotationClassDescriptor(annotation);

    // Create an AnnotationValue
    AnnotationValue annotationValue = new AnnotationValue(nullnessAnnotationType);

    // Destructively add the annotation to the MethodInfo object
    xmethod.addAnnotation(annotationValue);
}
 

import edu.umd.cs.findbugs.ba.XMethod; //导入依赖的package包/类
@Override
public void visitParameterAnnotation(int p, String annotationClass, Map<String, ElementValue> map, boolean runtimeVisible) {
    if (database == null) {
        return;
    }

    NullnessAnnotation n = NullnessAnnotation.Parser.parse(annotationClass);
    annotationClass = lastPortion(annotationClass);
    if (n == null)
        return;

    XMethod xmethod = XFactory.createXMethod(this);
    if (DEBUG) {
        System.out.println("Parameter " + p + " @" + annotationClass.substring(annotationClass.lastIndexOf('/') + 1) + " in "
                + xmethod.toString());
    }
    XMethodParameter xparameter = new XMethodParameter(xmethod, p);

    database.addDirectAnnotation(xparameter, n);

}
 

import edu.umd.cs.findbugs.ba.XMethod; //导入依赖的package包/类
private void checkForConflictingValues(XMethod xMethod, CFG cfg,
        TypeQualifierValue typeQualifierValue, TypeQualifierValueSet forwardsFact, TypeQualifierValueSet backwardsFact,
        Location locationToReport, Location locationWhereDoomedValueIsObserved, ValueNumberFrame vnaFrame) throws CheckedAnalysisException {
    Set<ValueNumber> valueNumberSet = new HashSet<ValueNumber>();
    valueNumberSet.addAll(forwardsFact.getValueNumbers());
    valueNumberSet.addAll(backwardsFact.getValueNumbers());

    for (ValueNumber vn : valueNumberSet) {
        FlowValue forward = forwardsFact.getValue(vn);
        FlowValue backward = backwardsFact.getValue(vn);
        if (!FlowValue.valuesConflict(typeQualifierValue.isStrictQualifier() && !xMethod.isIdentity(), forward, backward))
            continue;

        if (DEBUG) {
            System.out.println("Check " + vn + ": forward=" + forward + ", backward=" + backward + " at " + checkLocation);
            forwardsFact.getValue(vn);
            backwardsFact.getValue(vn);
        }

        emitDataflowWarning(xMethod, typeQualifierValue, forwardsFact, backwardsFact, vn, forward, backward,
                locationToReport, locationWhereDoomedValueIsObserved, vnaFrame);

    }
}
 

import edu.umd.cs.findbugs.ba.XMethod; //导入依赖的package包/类
/**
 * Get the effective inherited TypeQualifierAnnotation on given instance
 * method.
 *
 * @param o
 *            an XMethod
 * @param typeQualifierValue
 *            the kind of TypeQualifierValue we are looking for
 * @return effective TypeQualifierAnnotation inherited from overridden
 *         supertype methods, or null if there is no inherited
 *         TypeQualifierAnnotation
 */
public static TypeQualifierAnnotation getInheritedTypeQualifierAnnotation(XMethod o, TypeQualifierValue<?> typeQualifierValue) {
    assert !o.isStatic();

    ReturnTypeAnnotationAccumulator accumulator = new ReturnTypeAnnotationAccumulator(typeQualifierValue, o);
    try {
        AnalysisContext.currentAnalysisContext().getSubtypes2().traverseSupertypes(o.getClassDescriptor(), accumulator);
        TypeQualifierAnnotation result = accumulator.getResult().getEffectiveTypeQualifierAnnotation();
        if (result == null && accumulator.overrides())
            return TypeQualifierAnnotation.OVERRIDES_BUT_NO_ANNOTATION;
        return result;
    } catch (ClassNotFoundException e) {
        AnalysisContext.currentAnalysisContext().getLookupFailureCallback().reportMissingClass(e);
        return null;
    }
}
 

import edu.umd.cs.findbugs.ba.XMethod; //导入依赖的package包/类
private boolean bad(Item left, Item right) {
    XMethod m = left.getReturnValueOf();

    if (m == null)
        return false;
    Object value = right.getConstant();
    if (!(value instanceof Integer) || ((Integer) value).intValue() == 0)
        return false;
    if (m.isStatic() || !m.isPublic())
        return false;

    if (m.getName().equals("compareTo") && m.getSignature().equals("(Ljava/lang/Object;)I"))
        return true;
    if (m.getName().equals("compare") && m.getSignature().equals("(Ljava/lang/Object;Ljava/lang/Object;)I"))
        return true;

    return false;

}
 

import edu.umd.cs.findbugs.ba.XMethod; //导入依赖的package包/类
private boolean safeCallToPrimateParseMethod(XMethod calledMethod, Location location) {
    int position = location.getHandle().getPosition();

    if (calledMethod.getClassName().equals("java.lang.Integer")) {

        ConstantPool constantPool = classContext.getJavaClass().getConstantPool();
        Code code = method.getCode();

        int catchSize;

        catchSize = Util.getSizeOfSurroundingTryBlock(constantPool, code, "java/lang/NumberFormatException", position);
        if (catchSize < Integer.MAX_VALUE)
            return true;
        catchSize = Util.getSizeOfSurroundingTryBlock(constantPool, code, "java/lang/IllegalArgumentException", position);
        if (catchSize < Integer.MAX_VALUE)
            return true;

        catchSize = Util.getSizeOfSurroundingTryBlock(constantPool, code, "java/lang/RuntimeException", position);
        if (catchSize < Integer.MAX_VALUE)
            return true;
        catchSize = Util.getSizeOfSurroundingTryBlock(constantPool, code, "java/lang/Exception", position);
        if (catchSize < Integer.MAX_VALUE)
            return true;
    }
    return false;
}
 

import edu.umd.cs.findbugs.ba.XMethod; //导入依赖的package包/类
/**
 * Get the effective TypeQualifierAnnotation on given method parameter.
 * Takes into account inherited and default (outer scope) annotations. Also
 * takes exclusive qualifiers into account.
 *
 * @param xmethod
 *            a method
 * @param parameter
 *            a parameter (0 == first parameter)
 * @param typeQualifierValue
 *            the kind of TypeQualifierValue we are looking for
 * @return effective TypeQualifierAnnotation on the parameter, or null if
 *         there is no effective TypeQualifierAnnotation
 */
public static @CheckForNull
TypeQualifierAnnotation getEffectiveTypeQualifierAnnotation(final XMethod xmethod, final int parameter,
        TypeQualifierValue typeQualifierValue) {

    TypeQualifierAnnotation tqa = computeEffectiveTypeQualifierAnnotation(typeQualifierValue, xmethod, parameter);

    if (CHECK_EXCLUSIVE && tqa == null && typeQualifierValue.isExclusiveQualifier()) {
        tqa = computeExclusiveQualifier(typeQualifierValue, new ComputeEffectiveTypeQualifierAnnotation() {
            public TypeQualifierAnnotation compute(TypeQualifierValue tqv) {
                return computeEffectiveTypeQualifierAnnotation(tqv, xmethod, parameter);
            }

            @Override
            public String toString() {
                return "parameter " + parameter + " of " + xmethod;
            }
        });
    }

    return tqa;
}
 

import edu.umd.cs.findbugs.ba.XMethod; //导入依赖的package包/类
/**
 * Get the effective inherited TypeQualifierAnnotation on the given instance
 * method parameter.
 *
 * @param xmethod
 *            an instance method
 * @param parameter
 *            a parameter (0 == first parameter)
 * @param typeQualifierValue
 *            the kind of TypeQualifierValue we are looking for
 * @return effective inherited TypeQualifierAnnotation on the parameter, or
 *         null if there is not effective TypeQualifierAnnotation
 */
private static @CheckForNull
TypeQualifierAnnotation getInheritedTypeQualifierAnnotation(XMethod xmethod, int parameter,
        TypeQualifierValue typeQualifierValue) {
    assert !xmethod.isStatic();

    ParameterAnnotationAccumulator accumulator = new ParameterAnnotationAccumulator(typeQualifierValue, xmethod, parameter);
    try {
        AnalysisContext.currentAnalysisContext().getSubtypes2().traverseSupertypes(xmethod.getClassDescriptor(), accumulator);
        TypeQualifierAnnotation result = accumulator.getResult().getEffectiveTypeQualifierAnnotation();
        if (result == null && accumulator.overrides())
            return TypeQualifierAnnotation.OVERRIDES_BUT_NO_ANNOTATION;
        return result;
    } catch (ClassNotFoundException e) {
        AnalysisContext.currentAnalysisContext().getLookupFailureCallback().reportMissingClass(e);
        return null;
    }
}
 

import edu.umd.cs.findbugs.ba.XMethod; //导入依赖的package包/类
public @CheckForNull
XMethod getXMethodOperand() {
    if (getReferencedXClass() != null && referencedXMethod == null) {
        referencedXMethod = Hierarchy2.findInvocationLeastUpperBound(getReferencedXClass(), nameConstantOperand,
                sigConstantOperand, opcode == INVOKESTATIC, opcode == INVOKEINTERFACE);
    }

    return referencedXMethod;
}
 

import edu.umd.cs.findbugs.ba.XMethod; //导入依赖的package包/类
private boolean isStaticOnlyClass(XClass xClass)  {

        if (xClass.getInterfaceDescriptorList().length > 0)
            return false;
        ClassDescriptor superclassDescriptor = xClass.getSuperclassDescriptor();
        if (superclassDescriptor == null)
            return false;
        String superClassName = superclassDescriptor.getClassName();
        if (!superClassName.equals("java/lang/Object"))
            return false;
        int staticCount = 0;

        List<? extends XMethod> methods = xClass.getXMethods();
        for (XMethod m : methods) {
            if (m.isStatic()) {
                staticCount++;
            } else if (!m.getName().equals("<init>") || !m.getSignature().equals("()V"))
                return false;
        }

        List<? extends XField> fields = xClass.getXFields();
        for (XField f : fields) {
            if (f.isStatic()) {
                staticCount++;
            } else if (!f.isPrivate())
                return false;
        }

        if (staticCount == 0)
            return false;
        return true;

    }