private String fileNameFor(final String packageName, final String sourceName) { String result; SourceFinder sourceFinder = AnalysisContext.currentAnalysisContext().getSourceFinder(); try { result = sourceFinder.findSourceFile(packageName, sourceName).getFullFileName(); } catch (IOException e) { result = packageName.replace('.', File.separatorChar) + File.separatorChar + sourceName; } return result; }
@Override public void visitClassContext(ClassContext classContext) { boolean fullAnalysis = AnalysisContext.currentAnalysisContext().getBoolProperty( FindBugsAnalysisFeatures.INTERPROCEDURAL_ANALYSIS_OF_REFERENCED_CLASSES); if (!fullAnalysis && !AnalysisContext.currentAnalysisContext().isApplicationClass(classContext.getJavaClass())) { return; } if (VERBOSE_DEBUG) { System.out.println("Visiting class " + classContext.getJavaClass().getClassName()); } for (Method m : classContext.getMethodsInCallOrder()) { considerMethod(classContext, m); } }
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; } }
static public boolean analyzingApplicationClass() { AnalysisContext context = AnalysisContext.currentAnalysisContext(); if (context == null) { return false; } ClassDescriptor clazz = context.getClassBeingAnalyzed(); if (clazz == null) { return false; } return context.isApplicationClass(clazz); }
/** * Constructor. * * @param reporter * the BugReporter to which warnings should eventually be * reported */ public BugAccumulator(BugReporter reporter) { this.reporter = reporter; performAccumulation = AnalysisContext.currentAnalysisContext().getBoolProperty(AnalysisFeatures.MERGE_SIMILAR_WARNINGS); }
public static void setAppClassList(List<ClassDescriptor> appClassList) { AnalysisContext analysisContext = AnalysisContext .currentAnalysisContext(); analysisContext.setAppClassList(appClassList); }
Profiler profiler = bugReporter.getProjectStats().getProfiler(); profiler.start(this.getClass()); AnalysisContext.currentXFactory().canonicalizeAll(); try { boolean multiplePasses = executionPlan.getNumPasses() > 1; XFactory factory = AnalysisContext.currentXFactory(); Collection<ClassDescriptor> badClasses = new LinkedList<>(); for (ClassDescriptor desc : referencedClassSet) { factory.intern(info); } catch (CheckedAnalysisException e) { AnalysisContext.logError("Couldn't get class info for " + desc, e); badClasses.add(desc); } catch (RuntimeException e) { AnalysisContext.logError("Couldn't get class info for " + desc, e); badClasses.add(desc); AnalysisContext.currentXFactory().canonicalizeAll(); if (PROGRESS || LIST_ORDER) { System.out.printf("%6d : Pass %d: %d classes%n", (System.currentTimeMillis() - startTime)/1000, passCount, classCollection.size()); return classNameAndInfo.getCalledClassDescriptors(); } catch (CheckedAnalysisException e2) { AnalysisContext.logError("error while analyzing " + e.getClassName(), e2); return Collections.emptyList(); AnalysisContext currentAnalysisContext = AnalysisContext.currentAnalysisContext(); currentAnalysisContext.updateDatabases(passCount);
@Override public void visitJavaClass(JavaClass obj) { if (AnalysisContext.currentAnalysisContext().isApplicationClass(obj)) { super.visitJavaClass(obj); } }
kind = EqualsKindSummary.KindOfEquals.COMPARE_EQUALS; } else { if (AnalysisContext.currentAnalysisContext().isApplicationClass(getThisClass())) { bugReporter .reportBug(new BugInstance(this, "EQ_UNUSUAL", Priorities.NORMAL_PRIORITY).addClassAndMethod(this)); Set<ClassDescriptor> subtypes = AnalysisContext.currentAnalysisContext().getSubtypes2() .getSubtypes(classDescriptor); if (subtypes.size() > 1) { Set<ClassDescriptor> subtypes = AnalysisContext.currentAnalysisContext().getSubtypes2() .getSubtypes(classDescriptor); if (subtypes.size() > 1) {
type = item.getJavaClass(); } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); priority--; if (!AnalysisContext.currentAnalysisContext()/* .getSubtypes() */.isApplicationClass(type)) { priority++;
AnalysisContext currentAnalysisContext = AnalysisContext.currentAnalysisContext(); XFactory xFactory = AnalysisContext.currentXFactory(); for (XField f : AnalysisContext.currentXFactory().allFields()) { ClassDescriptor classDescriptor = f.getClassDescriptor(); if (currentAnalysisContext.isApplicationClass(classDescriptor) && !currentAnalysisContext.isTooBig(classDescriptor) && !xFactory.isReflectiveClass(classDescriptor)) { declaredFields.add(f); AnalysisContext analysisContext = AnalysisContext.currentAnalysisContext(); Subtypes2 subtypes2 = analysisContext.getSubtypes2();
/** * Set the CodeExceptionGen object. Marks this basic block as the entry * point of an exception handler. * * @param exceptionGen * the CodeExceptionGen object for the block */ public void setExceptionGen(@Nullable TypeMerger m, CodeExceptionGen exceptionGen) { if (this.exceptionGen != null) { AnalysisContext.logError("Multiple exception handlers"); } this.exceptionGen = exceptionGen; }
@Override public boolean match(String s) { try { return Hierarchy.isSubtype(s, className); } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); return false; } } }
/** * Create the AnalysisContext that will serve as the BCEL-compatibility * layer over the AnalysisCache. * * @param project * The project * @param appClassList * list of ClassDescriptors identifying application classes * @param sourceInfoFileName * name of source info file (null if none) */ public static void createAnalysisContext(Project project, List<ClassDescriptor> appClassList, @CheckForNull String sourceInfoFileName) throws IOException { AnalysisContext analysisContext = new AnalysisContext(project); // Make this the current analysis context AnalysisContext.setCurrentAnalysisContext(analysisContext); // Make the AnalysisCache the backing store for // the BCEL Repository analysisContext.clearRepository(); // If needed, load SourceInfoMap if (sourceInfoFileName != null) { SourceInfoMap sourceInfoMap = analysisContext.getSourceInfoMap(); sourceInfoMap.read(new FileInputStream(sourceInfoFileName)); } }
/** * file a ClassNotFoundException with the lookupFailureCallback * * @see #getLookupFailureCallback() */ static public void reportMissingClass(ClassNotFoundException e) { requireNonNull(e, "argument is null"); String missing = AbstractBugReporter.getMissingClassName(e); if (skipReportingMissingClass(missing)) { return; } if (!analyzingApplicationClass()) { return; } RepositoryLookupFailureCallback lookupFailureCallback = getCurrentLookupFailureCallback(); if (lookupFailureCallback != null) { lookupFailureCallback.reportMissingClass(e); } }
boolean missingClassWarningsSuppressed = AnalysisContext.currentAnalysisContext().setMissingClassWarningsSuppressed(true); sortedMethodSet.addAll(propertyMap.keySet()); for (KeyType key : sortedMethodSet) { if (AnalysisContext.currentAnalysisContext().isApplicationClass(key.getClassDescriptor())) { AnalysisContext.currentAnalysisContext().setMissingClassWarningsSuppressed(missingClassWarningsSuppressed);
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; }
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); }
&& AnalysisContext.currentAnalysisContext().isApplicationClass(getThisClass())) { inferredMethod = new BugInstance("TESTING", NORMAL_PRIORITY).addClassAndMethod(this); } else { XFactory xFactory = AnalysisContext.currentXFactory(); xFactory.addFunctionThatMightBeMistakenForProcedures(getMethodDescriptor()); if (inferredMethod != null) {
/** * 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; } }