@Override public boolean match(String s) { try { return Hierarchy.isSubtype(s, className); } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); return false; } } }
static public void reportMissingClass(edu.umd.cs.findbugs.classfile.MissingClassException e) { requireNonNull(e, "argument is null"); reportMissingClass(e.getClassDescriptor()); }
static public void reportMissingClass(edu.umd.cs.findbugs.ba.MissingClassException e) { requireNonNull(e, "argument is null"); reportMissingClass(e.getClassDescriptor()); }
static boolean areRelated(String sig, String superSig) { try { if (sig.equals(superSig)) { return true; } if (sig.charAt(0) == 'L' && superSig.charAt(0) == 'L') { sig = sig.substring(1, sig.length() - 1); superSig = superSig.substring(1, superSig.length() - 1); return Hierarchy.isSubtype(sig, superSig); } } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); } return false; } }
@Nonnull public BugInstance addEqualsMethodUsed(ClassDescriptor expectedClass) { try { Set<XMethod> targets = Hierarchy2.resolveVirtualMethodCallTargets(expectedClass, "equals", "(Ljava/lang/Object;)Z", false, false); addEqualsMethodUsed(targets); } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); } return this; }
public boolean isApplicationClass(ClassDescriptor descriptor) { assert descriptor != null; try { return resolveClassVertex(descriptor).isApplicationClass(); } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); return false; } }
@Nullable private CheckReturnValueAnnotation getResolvedAnnotationOnConstructor(XMethod m) { try { if (throwableClass != null && Repository.instanceOf(m.getClassName(), throwableClass)) { return CheckReturnValueAnnotation.CHECK_RETURN_VALUE_VERY_HIGH; } } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); } if ("java.lang.Thread".equals(m.getClassName())) { return CheckReturnValueAnnotation.CHECK_RETURN_VALUE_VERY_HIGH; } try { if (threadClass != null && Repository.instanceOf(m.getClassName(), threadClass)) { return CheckReturnValueAnnotation.CHECK_RETURN_VALUE_LOW; } } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); } return null; }
private boolean extendsConcurrentMap(@DottedClassName String className) { if ("java.util.concurrent.ConcurrentHashMap".equals(className) || className.equals(concurrentMapDescriptor.getDottedClassName())) { return true; } ClassDescriptor c = DescriptorFactory.createClassDescriptorFromDottedClassName(className); Subtypes2 subtypes2 = AnalysisContext.currentAnalysisContext().getSubtypes2(); try { if (subtypes2.isSubtype(c, concurrentMapDescriptor)) { return true; } } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); } return false; }
/** * Add a ClassVertex representing a missing class. * * @param missingClassDescriptor * ClassDescriptor naming a missing class * @param isInterfaceEdge * @return the ClassVertex representing the missing class */ private ClassVertex addClassVertexForMissingClass(ClassDescriptor missingClassDescriptor, boolean isInterfaceEdge) { ClassVertex missingClassVertex = ClassVertex.createMissingClassVertex(missingClassDescriptor, isInterfaceEdge); missingClassVertex.setFinished(true); addVertexToGraph(missingClassDescriptor, missingClassVertex); AnalysisContext.currentAnalysisContext(); AnalysisContext.reportMissingClass(missingClassDescriptor); return missingClassVertex; } }
public static boolean likelyTestCase(XMethod m) { if (m.getAnnotation(JUNIT4TEST) != null) { return true; } ClassDescriptor c = m.getClassDescriptor(); if (m.getName().startsWith("test") || m.getName().startsWith("assert")) { Subtypes2 subtypes2 = AnalysisContext.currentAnalysisContext().getSubtypes2(); try { if (subtypes2.isSubtype(c, JUNIT3TESTCASE)) { return true; } } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); } } return false; }
public static boolean instanceOf(ClassDescriptor subDescriptor, @DottedClassName String dottedSupertype) { Subtypes2 subtypes2 = AnalysisContext.currentAnalysisContext().getSubtypes2(); ClassDescriptor superDescriptor = DescriptorFactory.createClassDescriptorFromDottedClassName(dottedSupertype); try { return subtypes2.isSubtype(subDescriptor, superDescriptor); } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); return false; } }
@Override public void visitJavaClass(JavaClass obj) { try { obj.getSuperClass(); } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); return; } String superclassName2 = getSuperclassName(); boolean weird = "java.lang.Object".equals(superclassName2) && obj.getInterfaceIndices().length == 0; boolean hasAnonymousName = ClassName.isLocalOrAnonymous(obj.getClassName()); boolean isAnonymousInnerClass = hasAnonymousName && !weird; if (isAnonymousInnerClass) { super.visitJavaClass(obj); } }
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; }
private boolean hasTestMethods(JavaClass jClass) { boolean foundTest = false; Method[] methods = jClass.getMethods(); for (Method m : methods) { if (m.isPublic() && m.getName().startsWith("test") && m.getSignature().equals("()V")) { return true; } if (m.getName().startsWith("runTest") && m.getSignature().endsWith("()V")) { return true; } } if (hasSuite(methods)) { return true; } try { JavaClass sClass = jClass.getSuperClass(); if (sClass != null) { return hasTestMethods(sClass); } } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); } return false; }
public static boolean instanceOf(JavaClass subtype, @DottedClassName String dottedSupertype) { if (subtype.getClassName().equals(dottedSupertype) || subtype.getSuperclassName().equals(dottedSupertype)) { return true; } if ("java.lang.Object".equals(subtype.getSuperclassName()) && subtype.getInterfaceIndices().length == 0) { return false; } Subtypes2 subtypes2 = AnalysisContext.currentAnalysisContext().getSubtypes2(); ClassDescriptor subDescriptor = DescriptorFactory.createClassDescriptor(subtype); ClassDescriptor superDescriptor = DescriptorFactory.createClassDescriptorFromDottedClassName(dottedSupertype); try { return subtypes2.isSubtype(subDescriptor, superDescriptor); } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); return false; } }
@Override public void visitClassContext(ClassContext classContext) { JavaClass javaClass = classContext.getJavaClass(); try { if(!Hierarchy.isSubtype(javaClass.getClassName(), "javax.servlet.http.HttpServlet")) { return; } } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); } for (Method m : javaClass.getMethods()) { try { analyzeMethod(m, classContext); } catch (CFGBuilderException e) { } catch (DataflowAnalysisException e) { } } }
public static boolean instanceOf(@DottedClassName String dottedSubtype, @DottedClassName String dottedSupertype) { Subtypes2 subtypes2 = AnalysisContext.currentAnalysisContext().getSubtypes2(); ClassDescriptor subDescriptor = DescriptorFactory.createClassDescriptorFromDottedClassName(dottedSubtype); ClassDescriptor superDescriptor = DescriptorFactory.createClassDescriptorFromDottedClassName(dottedSupertype); try { return subtypes2.isSubtype(subDescriptor, superDescriptor); } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); return false; } }
@Override public void visitClassContext(ClassContext classContext) { JavaClass javaClass = classContext.getJavaClass(); try { if (!Hierarchy.isSubtype(javaClass.getClassName(), "javax.servlet.http.HttpServlet")) { return; } } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); } for (Method m : javaClass.getMethods()) { try { analyzeMethod(m, classContext); } catch (CFGBuilderException | DataflowAnalysisException e) { AnalysisContext.logError("Cannot analyze method", e); } } }
static SourceLineAnnotation getSourceAnnotationForClass(String className, String sourceFileName) { int lastLine = -1; int firstLine = Integer.MAX_VALUE; try { JavaClass targetClass = AnalysisContext.currentAnalysisContext().lookupClass(className); for (Method m : targetClass.getMethods()) { Code c = m.getCode(); if (c != null) { LineNumberTable table = c.getLineNumberTable(); if (table != null) { for (LineNumber line : table.getLineNumberTable()) { lastLine = Math.max(lastLine, line.getLineNumber()); firstLine = Math.min(firstLine, line.getLineNumber()); } } } } } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); } if (firstLine < Integer.MAX_VALUE) { return new SourceLineAnnotation(className, sourceFileName, firstLine, lastLine, -1, -1); } return SourceLineAnnotation.createUnknown(className, sourceFileName); }
@Override public void visit(JavaClass obj) { isTigerOrHigher = obj.getMajor() >= Const.MAJOR_1_5; try { Subtypes2 subtypes2 = AnalysisContext.currentAnalysisContext().getSubtypes2(); ClassDescriptor me = getClassDescriptor(); if (subtypes2.isSubtype(me, MAP_ENTRY) && subtypes2.isSubtype(me, ITERATOR)) { bugReporter.reportBug(new BugInstance(this, "PZ_DONT_REUSE_ENTRY_OBJECTS_IN_ITERATORS", NORMAL_PRIORITY) .addClass(this).addString("shouldn't reuse Iterator as a Map.Entry")); } } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); } }