edu.umd.cs.findbugs.BugInstance Maven / Gradle / Ivy

* For information on type descriptors,
* see http://java.sun.com/docs/books/vmspec/2nd-edition/html/ClassFile.doc. * html#14152
* or http://www.murrayc.com/learning/java/java_classfileformat.shtml# * TypeDescriptors * * @param typeDescriptor * a jvm type descriptor, such as "[I" * @return this object */ @Nonnull public BugInstance addType(String typeDescriptor) { TypeAnnotation typeAnnotation = new TypeAnnotation(typeDescriptor); add(typeAnnotation); return this; } @Nonnull public BugInstance addType(Type type) { TypeAnnotation typeAnnotation = new TypeAnnotation(type); add(typeAnnotation); return this; } @Nonnull public BugInstance addFoundAndExpectedType(Type foundType, Type expectedType) { add(new TypeAnnotation(foundType, TypeAnnotation.FOUND_ROLE)); add(new TypeAnnotation(expectedType, TypeAnnotation.EXPECTED_ROLE)); return this; } @Nonnull public BugInstance addFoundAndExpectedType(String foundType, String expectedType) { add(new TypeAnnotation(foundType, TypeAnnotation.FOUND_ROLE)); add(new TypeAnnotation(expectedType, TypeAnnotation.EXPECTED_ROLE)); return this; } @Nonnull public BugInstance addEqualsMethodUsed(ClassDescriptor expectedClass) { try { Set targets = Hierarchy2.resolveVirtualMethodCallTargets(expectedClass, "equals", "(Ljava/lang/Object;)Z", false, false); addEqualsMethodUsed(targets); } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); } return this; } @Nonnull public BugInstance addEqualsMethodUsed(@CheckForNull Collection equalsMethods) { if (equalsMethods == null) { return this; } if (equalsMethods.size() < 5) { for (XMethod m : equalsMethods) { addMethod(m).describe(MethodAnnotation.METHOD_EQUALS_USED); } } else { addMethod(equalsMethods.iterator().next()).describe(MethodAnnotation.METHOD_EQUALS_USED); } return this; } @Nonnull public BugInstance addTypeOfNamedClass(@DottedClassName String typeName) { TypeAnnotation typeAnnotation = new TypeAnnotation("L" + typeName.replace('.', '/') + ";"); add(typeAnnotation); return this; } @Nonnull public BugInstance addType(ClassDescriptor c) { TypeAnnotation typeAnnotation = new TypeAnnotation(c.getSignature()); add(typeAnnotation); return this; } /* * ---------------------------------------------------------------------- * Field annotation adders * ---------------------------------------------------------------------- */ /** * Add a field annotation. * * @param className * name of the class containing the field * @param fieldName * the name of the field * @param fieldSig * type signature of the field * @param isStatic * whether or not the field is static * @return this object */ @Nonnull public BugInstance addField(String className, String fieldName, String fieldSig, boolean isStatic) { addField(new FieldAnnotation(className, fieldName, fieldSig, isStatic)); return this; } /** * Add a field annotation. * * @param className * name of the class containing the field * @param fieldName * the name of the field * @param fieldSig * type signature of the field * @param accessFlags * access flags for the field * @return this object */ @Nonnull public BugInstance addField(String className, String fieldName, String fieldSig, int accessFlags) { addField(new FieldAnnotation(className, fieldName, fieldSig, accessFlags)); return this; } @Nonnull public BugInstance addField(PreorderVisitor visitor) { FieldAnnotation fieldAnnotation = FieldAnnotation.fromVisitedField(visitor); return addField(fieldAnnotation); } /** * Add a field annotation * * @param fieldAnnotation * the field annotation * @return this object */ @Nonnull public BugInstance addField(FieldAnnotation fieldAnnotation) { add(fieldAnnotation); return this; } /** * Add a field annotation for a FieldVariable matched in a ByteCodePattern. * * @param field * the FieldVariable * @return this object */ @Nonnull public BugInstance addField(FieldVariable field) { return addField(field.getClassName(), field.getFieldName(), field.getFieldSig(), field.isStatic()); } /** * Add a field annotation for an XField. * * @param xfield * the XField * @return this object */ @Nonnull public BugInstance addOptionalField(@CheckForNull XField xfield) { if (xfield == null) { return this; } return addField(xfield.getClassName(), xfield.getName(), xfield.getSignature(), xfield.isStatic()); } /** * Add a field annotation for an XField. * * @param xfield * the XField * @return this object */ @Nonnull public BugInstance addField(XField xfield) { return addField(xfield.getClassName(), xfield.getName(), xfield.getSignature(), xfield.isStatic()); } /** * Add a field annotation for a FieldDescriptor. * * @param fieldDescriptor * the FieldDescriptor * @return this object */ @Nonnull public BugInstance addField(FieldDescriptor fieldDescriptor) { FieldAnnotation fieldAnnotation = FieldAnnotation.fromFieldDescriptor(fieldDescriptor); add(fieldAnnotation); return this; } /** * Add a field annotation for the field which has just been accessed by the * method currently being visited by given visitor. Assumes that a * getfield/putfield or getstatic/putstatic has just been seen. * * @param visitor * the DismantleBytecode object * @return this object */ @Nonnull public BugInstance addReferencedField(DismantleBytecode visitor) { FieldAnnotation f = FieldAnnotation.fromReferencedField(visitor); addField(f); return this; } /** * Add a field annotation for the field referenced by the FieldAnnotation * parameter */ @Nonnull public BugInstance addReferencedField(FieldAnnotation fa) { addField(fa); return this; } /** * Add a field annotation for the field which is being visited by given * visitor. * * @param visitor * the visitor * @return this object */ @Nonnull public BugInstance addVisitedField(PreorderVisitor visitor) { FieldAnnotation f = FieldAnnotation.fromVisitedField(visitor); addField(f); return this; } /** * Local variable adders */ @Nonnull public BugInstance addOptionalLocalVariable(DismantleBytecode dbc, OpcodeStack.Item item) { int register = item.getRegisterNumber(); if (register >= 0) { this.add(LocalVariableAnnotation.getLocalVariableAnnotation(dbc.getMethod(), register, dbc.getPC() - 1, dbc.getPC())); } return this; } /* * ---------------------------------------------------------------------- * Method annotation adders * ---------------------------------------------------------------------- */ /** * Add a method annotation. If this is the first method annotation added, it * becomes the primary method annotation. * * @param className * name of the class containing the method * @param methodName * name of the method * @param methodSig * type signature of the method * @param isStatic * true if the method is static, false otherwise * @return this object */ @Nonnull public BugInstance addMethod(String className, String methodName, String methodSig, boolean isStatic) { addMethod(MethodAnnotation.fromForeignMethod(className, methodName, methodSig, isStatic)); return this; } /** * Add a method annotation. If this is the first method annotation added, it * becomes the primary method annotation. * * @param className * name of the class containing the method * @param methodName * name of the method * @param methodSig * type signature of the method * @param accessFlags * accessFlags for the method * @return this object */ @Nonnull public BugInstance addMethod(@SlashedClassName String className, String methodName, String methodSig, int accessFlags) { addMethod(MethodAnnotation.fromForeignMethod(className, methodName, methodSig, accessFlags)); return this; } /** * Add a method annotation. If this is the first method annotation added, it * becomes the primary method annotation. If the method has source line * information, then a SourceLineAnnotation is added to the method. * * @param methodGen * the MethodGen object for the method * @param sourceFile * source file method is defined in * @return this object */ @Nonnull public BugInstance addMethod(MethodGen methodGen, String sourceFile) { String className = methodGen.getClassName(); MethodAnnotation methodAnnotation = new MethodAnnotation(className, methodGen.getName(), methodGen.getSignature(), methodGen.isStatic()); addMethod(methodAnnotation); addSourceLinesForMethod(methodAnnotation, SourceLineAnnotation.fromVisitedMethod(methodGen, sourceFile)); return this; } /** * Add a method annotation. If this is the first method annotation added, it * becomes the primary method annotation. If the method has source line * information, then a SourceLineAnnotation is added to the method. * * @param javaClass * the class the method is defined in * @param method * the method * @return this object */ @Nonnull public BugInstance addMethod(JavaClass javaClass, Method method) { MethodAnnotation methodAnnotation = new MethodAnnotation(javaClass.getClassName(), method.getName(), method.getSignature(), method.isStatic()); SourceLineAnnotation methodSourceLines = SourceLineAnnotation.forEntireMethod(javaClass, method); methodAnnotation.setSourceLines(methodSourceLines); addMethod(methodAnnotation); return this; } /** * Add a method annotation. If this is the first method annotation added, it * becomes the primary method annotation. If the method has source line * information, then a SourceLineAnnotation is added to the method. * * @param classAndMethod * JavaClassAndMethod identifying the method to add * @return this object */ @Nonnull public BugInstance addMethod(JavaClassAndMethod classAndMethod) { return addMethod(classAndMethod.getJavaClass(), classAndMethod.getMethod()); } /** * Add a method annotation for the method which the given visitor is * currently visiting. If the method has source line information, then a * SourceLineAnnotation is added to the method. * * @param visitor * the BetterVisitor * @return this object */ @Nonnull public BugInstance addMethod(PreorderVisitor visitor) { MethodAnnotation methodAnnotation = MethodAnnotation.fromVisitedMethod(visitor); addMethod(methodAnnotation); addSourceLinesForMethod(methodAnnotation, SourceLineAnnotation.fromVisitedMethod(visitor)); return this; } /** * Add a method annotation for the method which has been called by the * method currently being visited by given visitor. Assumes that the visitor * has just looked at an invoke instruction of some kind. * * @param visitor * the DismantleBytecode object * @return this object */ @Nonnull public BugInstance addCalledMethod(DismantleBytecode visitor) { return addMethod(MethodAnnotation.fromCalledMethod(visitor)).describe(MethodAnnotation.METHOD_CALLED); } @Nonnull public BugInstance addCalledMethod(XMethod m) { return addMethod(m).describe(MethodAnnotation.METHOD_CALLED); } /** * Add a method annotation. * * @param className * name of class containing called method * @param methodName * name of called method * @param methodSig * signature of called method * @param isStatic * true if called method is static, false if not * @return this object */ @Nonnull public BugInstance addCalledMethod(String className, String methodName, String methodSig, boolean isStatic) { return addMethod(MethodAnnotation.fromCalledMethod(className, methodName, methodSig, isStatic)).describe( MethodAnnotation.METHOD_CALLED); } /** * Add a method annotation for the method which is called by given * instruction. * * @param cpg * the constant pool for the method containing the call * @param inv * the InvokeInstruction * @return this object */ @Nonnull public BugInstance addCalledMethod(ConstantPoolGen cpg, InvokeInstruction inv) { String className = inv.getClassName(cpg); String methodName = inv.getMethodName(cpg); String methodSig = inv.getSignature(cpg); addMethod(className, methodName, methodSig, inv.getOpcode() == Const.INVOKESTATIC); describe(MethodAnnotation.METHOD_CALLED); return this; } /** * Add a method annotation for the method which is called by given * instruction. * * @param methodGen * the method containing the call * @param inv * the InvokeInstruction * @return this object */ @Nonnull public BugInstance addCalledMethod(MethodGen methodGen, InvokeInstruction inv) { ConstantPoolGen cpg = methodGen.getConstantPool(); return addCalledMethod(cpg, inv); } /** * Add a MethodAnnotation from an XMethod. * * @param xmethod * the XMethod * @return this object */ @Nonnull public BugInstance addMethod(XMethod xmethod) { addMethod(MethodAnnotation.fromXMethod(xmethod)); return this; } /** * Add a MethodAnnotation from an MethodDescriptor. * * @param method * the method * @return this object */ @Nonnull public BugInstance addMethod(MethodDescriptor method) { addMethod(MethodAnnotation.fromMethodDescriptor(method)); return this; } /** * Add a method annotation. If this is the first method annotation added, it * becomes the primary method annotation. * * @param methodAnnotation * the method annotation * @return this object */ @Nonnull public BugInstance addMethod(MethodAnnotation methodAnnotation) { add(methodAnnotation); return this; } /* * ---------------------------------------------------------------------- * Integer annotation adders * ---------------------------------------------------------------------- */ /** * Add an integer annotation. * * @param value * the integer value * @return this object */ @Nonnull public BugInstance addInt(int value) { add(new IntAnnotation(value)); return this; } /** * Add an annotation about a parameter * * @param index parameter index, starting from 0 * * @param role the role used to describe the parameter */ @Nonnull public BugInstance addParameterAnnotation(int index, String role) { return addInt(index + 1).describe(role); } /** * Add a String annotation. * * @param value * the String value * @return this object */ @Nonnull public BugInstance addString(String value) { add(StringAnnotation.fromRawString(value)); return this; } /** * Add a String annotation. * * @param c * the char value * @return this object */ @Nonnull public BugInstance addString(char c) { add(StringAnnotation.fromRawString(Character.toString(c))); return this; } /* * ---------------------------------------------------------------------- * Source line annotation adders * ---------------------------------------------------------------------- */ /** * Add a source line annotation. * * @param sourceLine * the source line annotation * @return this object */ @Nonnull public BugInstance addSourceLine(SourceLineAnnotation sourceLine) { add(sourceLine); return this; } /** * Add a source line annotation for instruction whose PC is given in the * method that the given visitor is currently visiting. Note that if the * method does not have line number information, then no source line * annotation will be added. * * @param visitor * a BytecodeScanningDetector that is currently visiting the * method * @param pc * bytecode offset of the instruction * @return this object */ @Nonnull public BugInstance addSourceLine(BytecodeScanningDetector visitor, int pc) { SourceLineAnnotation sourceLineAnnotation = SourceLineAnnotation.fromVisitedInstruction(visitor.getClassContext(), visitor, pc); if (sourceLineAnnotation != null) { add(sourceLineAnnotation); } return this; } /** * Add a source line annotation for instruction whose PC is given in the * method that the given visitor is currently visiting. Note that if the * method does not have line number information, then no source line * annotation will be added. * * @param classContext * the ClassContext * @param visitor * a PreorderVisitor that is currently visiting the method * @param pc * bytecode offset of the instruction * @return this object */ @Nonnull public BugInstance addSourceLine(ClassContext classContext, PreorderVisitor visitor, int pc) { SourceLineAnnotation sourceLineAnnotation = SourceLineAnnotation.fromVisitedInstruction(classContext, visitor, pc); if (sourceLineAnnotation != null) { add(sourceLineAnnotation); } return this; } /** * Add a source line annotation for the given instruction in the given * method. Note that if the method does not have line number information, * then no source line annotation will be added. * * @param classContext * the ClassContext * @param methodGen * the method being visited * @param sourceFile * source file the method is defined in * @param handle * the InstructionHandle containing the visited instruction * @return this object */ @Nonnull public BugInstance addSourceLine(ClassContext classContext, MethodGen methodGen, String sourceFile, @Nonnull InstructionHandle handle) { SourceLineAnnotation sourceLineAnnotation = SourceLineAnnotation.fromVisitedInstruction(classContext, methodGen, sourceFile, handle); if (sourceLineAnnotation != null) { add(sourceLineAnnotation); } return this; } /** * Add a source line annotation describing a range of instructions. * * @param classContext * the ClassContext * @param methodGen * the method * @param sourceFile * source file the method is defined in * @param start * the start instruction in the range * @param end * the end instruction in the range (inclusive) * @return this object */ @Nonnull public BugInstance addSourceLine(ClassContext classContext, MethodGen methodGen, String sourceFile, InstructionHandle start, InstructionHandle end) { // Make sure start and end are really in the right order. if (start.getPosition() > end.getPosition()) { InstructionHandle tmp = start; start = end; end = tmp; } SourceLineAnnotation sourceLineAnnotation = SourceLineAnnotation.fromVisitedInstructionRange(classContext, methodGen, sourceFile, start, end); if (sourceLineAnnotation != null) { add(sourceLineAnnotation); } return this; } /** * Add source line annotation for given Location in a method. * * @param classContext * the ClassContext * @param method * the Method * @param location * the Location in the method * @return this BugInstance */ @Nonnull public BugInstance addSourceLine(ClassContext classContext, Method method, Location location) { return addSourceLine(classContext, method, location.getHandle()); } /** * Add source line annotation for given Location in a method. * * @param methodDescriptor * the method * @param location * the Location in the method * @return this BugInstance */ @Nonnull public BugInstance addSourceLine(MethodDescriptor methodDescriptor, Location location) { try { IAnalysisCache analysisCache = Global.getAnalysisCache(); ClassContext classContext = analysisCache.getClassAnalysis(ClassContext.class, methodDescriptor.getClassDescriptor()); Method method = analysisCache.getMethodAnalysis(Method.class, methodDescriptor); return addSourceLine(classContext, method, location); } catch (CheckedAnalysisException e) { return addSourceLine(SourceLineAnnotation.createReallyUnknown(methodDescriptor.getClassDescriptor() .toDottedClassName())); } } /** * Add source line annotation for given Location in a method. * * @param classContext * the ClassContext * @param method * the Method * @param handle * InstructionHandle of an instruction in the method * @return this BugInstance */ @Nonnull public BugInstance addSourceLine(ClassContext classContext, Method method, InstructionHandle handle) { SourceLineAnnotation sourceLineAnnotation = SourceLineAnnotation.fromVisitedInstruction(classContext, method, handle.getPosition()); if (sourceLineAnnotation != null) { add(sourceLineAnnotation); } return this; } /** * Add a source line annotation describing the source line numbers for a * range of instructions in the method being visited by the given visitor. * Note that if the method does not have line number information, then no * source line annotation will be added. * * @param visitor * a BetterVisitor which is visiting the method * @param startPC * the bytecode offset of the start instruction in the range * @param endPC * the bytecode offset of the end instruction in the range * @return this object */ @Nonnull public BugInstance addSourceLineRange(BytecodeScanningDetector visitor, int startPC, int endPC) { SourceLineAnnotation sourceLineAnnotation = SourceLineAnnotation.fromVisitedInstructionRange(visitor.getClassContext(), visitor, startPC, endPC); requireNonNull(sourceLineAnnotation); add(sourceLineAnnotation); return this; } /** * Add a source line annotation describing the source line numbers for a * range of instructions in the method being visited by the given visitor. * Note that if the method does not have line number information, then no * source line annotation will be added. * * @param classContext * the ClassContext * @param visitor * a BetterVisitor which is visiting the method * @param startPC * the bytecode offset of the start instruction in the range * @param endPC * the bytecode offset of the end instruction in the range * @return this object */ @Nonnull public BugInstance addSourceLineRange(ClassContext classContext, PreorderVisitor visitor, int startPC, int endPC) { SourceLineAnnotation sourceLineAnnotation = SourceLineAnnotation.fromVisitedInstructionRange(classContext, visitor, startPC, endPC); requireNonNull(sourceLineAnnotation); add(sourceLineAnnotation); return this; } /** * Add a source line annotation for instruction currently being visited by * given visitor. Note that if the method does not have line number * information, then no source line annotation will be added. * * @param visitor * a BytecodeScanningDetector visitor that is currently visiting * the instruction * @return this object */ @Nonnull public BugInstance addSourceLine(BytecodeScanningDetector visitor) { SourceLineAnnotation sourceLineAnnotation = SourceLineAnnotation.fromVisitedInstruction(visitor); if (sourceLineAnnotation != null) { add(sourceLineAnnotation); } return this; } /** * Add a non-specific source line annotation. This will result in the entire * source file being displayed. * * @param className * the class name * @param sourceFile * the source file name * @return this object */ @Nonnull public BugInstance addUnknownSourceLine(String className, String sourceFile) { SourceLineAnnotation sourceLineAnnotation = SourceLineAnnotation.createUnknown(className, sourceFile); if (sourceLineAnnotation != null) { add(sourceLineAnnotation); } return this; } /* * ---------------------------------------------------------------------- * Formatting support * ---------------------------------------------------------------------- */ /** * Format a string describing this bug instance. * * @return the description */ @Nonnull public String getMessageWithoutPrefix() { BugPattern bugPattern = getBugPattern(); String pattern, shortPattern; pattern = getLongDescription(); shortPattern = bugPattern.getShortDescription(); try { FindBugsMessageFormat format = new FindBugsMessageFormat(pattern); return format.format(annotationList.toArray(new BugAnnotation[0]), getPrimaryClass()); } catch (RuntimeException e) { AnalysisContext.logError("Error generating bug msg ", e); return shortPattern + " [Error generating customized description]"; } } String getLongDescription() { return getBugPattern().getLongDescription().replaceAll("BUG_PATTERN", type); } public String getAbridgedMessage() { BugPattern bugPattern = getBugPattern(); String pattern = getLongDescription().replaceAll(" in \\{1\\}", ""); String shortPattern = bugPattern.getShortDescription(); try { FindBugsMessageFormat format = new FindBugsMessageFormat(pattern); return format.format(annotationList.toArray(new BugAnnotation[0]), getPrimaryClass(), true); } catch (RuntimeException e) { AnalysisContext.logError("Error generating bug msg ", e); return shortPattern + " [Error3 generating customized description]"; } } /** * Format a string describing this bug instance. * * @return the description */ public String getMessage() { BugPattern bugPattern = getBugPattern(); String pattern = bugPattern.getAbbrev() + ": " + getLongDescription(); FindBugsMessageFormat format = new FindBugsMessageFormat(pattern); try { return format.format(annotationList.toArray(new BugAnnotation[0]), getPrimaryClass()); } catch (RuntimeException e) { AnalysisContext.logError("Error generating bug msg ", e); return bugPattern.getShortDescription() + " [Error generating customized description]"; } } /** * Format a string describing this bug pattern, with the priority and type * at the beginning. e.g. * "(High Priority Correctness) Guaranteed null pointer dereference..." */ public String getMessageWithPriorityType() { return "(" + this.getPriorityTypeString() + ") " + this.getMessage(); } public String getMessageWithPriorityTypeAbbreviation() { return this.getPriorityTypeAbbreviation() + " " + this.getMessage(); } /** * Add a description to the most recently added bug annotation. * * @param description * the description to add * @return this object */ @Nonnull public BugInstance describe(String description) { annotationList.get(annotationList.size() - 1).setDescription(description); return this; } /** * Convert to String. This method returns the "short" message describing the * bug, as opposed to the longer format returned by getMessage(). The short * format is appropriate for the tree view in a GUI, where the annotations * are listed separately as part of the overall bug instance. */ @Override public String toString() { return I18N.instance().getShortMessage(type); } /* * ---------------------------------------------------------------------- * XML Conversion support * ---------------------------------------------------------------------- */ @Override public void writeXML(XMLOutput xmlOutput) throws IOException { writeXML(xmlOutput, null, false); } public int getCWEid() { BugPattern pattern = getBugPattern(); int cweid = pattern.getCWEid(); if (cweid != 0) { return cweid; } BugCode bugCode = pattern.getBugCode(); return bugCode.getCWEid(); } public void writeXML(XMLOutput xmlOutput, BugCollection bugCollection, boolean addMessages) throws IOException { XMLAttributeList attributeList = new XMLAttributeList().addAttribute("type", type).addAttribute("priority", String.valueOf(priority)); // Always add the rank attribute. attributeList.addAttribute("rank", Integer.toString(getBugRank())); BugPattern pattern = getBugPattern(); // The bug abbreviation and pattern category are // emitted into the XML for informational purposes only. // (The information is redundant, but might be useful // for processing tools that want to make sense of // bug instances without looking at the plugin descriptor.) attributeList.addAttribute("abbrev", pattern.getAbbrev()); attributeList.addAttribute("category", pattern.getCategory()); if (addMessages) { // Add a uid attribute, if we have a unique id. attributeList.addAttribute("instanceHash", getInstanceHash()); attributeList.addAttribute("instanceOccurrenceNum", Integer.toString(getInstanceOccurrenceNum())); attributeList.addAttribute("instanceOccurrenceMax", Integer.toString(getInstanceOccurrenceMax())); int cweid = getCWEid(); if (cweid != 0) { attributeList.addAttribute("cweid", Integer.toString(cweid)); } } else if (oldInstanceHash != null && !isInstanceHashConsistent()) { attributeList.addAttribute("oldInstanceHash", oldInstanceHash); } if (firstVersion > 0) { attributeList.addAttribute("first", Long.toString(firstVersion)); } if (lastVersion >= 0) { attributeList.addAttribute("last", Long.toString(lastVersion)); } if (introducedByChangeOfExistingClass) { attributeList.addAttribute("introducedByChange", "true"); } if (removedByChangeOfPersistingClass) { attributeList.addAttribute("removedByChange", "true"); } xmlOutput.openTag(ELEMENT_NAME, attributeList); if (addMessages) { BugPattern bugPattern = getBugPattern(); xmlOutput.openTag("ShortMessage"); xmlOutput.writeText(bugPattern.getShortDescription()); xmlOutput.closeTag("ShortMessage"); xmlOutput.openTag("LongMessage"); if (FindBugsDisplayFeatures.isAbridgedMessages()) { xmlOutput.writeText(this.getAbridgedMessage()); } else { xmlOutput.writeText(this.getMessageWithoutPrefix()); } xmlOutput.closeTag("LongMessage"); } Map primaryAnnotations; if (addMessages) { primaryAnnotations = new IdentityHashMap<>(); primaryAnnotations.put(getPrimarySourceLineAnnotation(), null); primaryAnnotations.put(getPrimaryClass(), null); primaryAnnotations.put(getPrimaryField(), null); primaryAnnotations.put(getPrimaryMethod(), null); } else { primaryAnnotations = Collections.emptyMap(); } boolean foundSourceAnnotation = false; for (BugAnnotation annotation : annotationList) { if (annotation instanceof SourceLineAnnotation) { foundSourceAnnotation = true; } annotation.writeXML(xmlOutput, addMessages, primaryAnnotations.containsKey(annotation)); } if (!foundSourceAnnotation && addMessages) { SourceLineAnnotation synth = getPrimarySourceLineAnnotation(); synth.setSynthetic(true); synth.writeXML(xmlOutput, addMessages, false); } if (propertyListHead != null) { List props = new ArrayList<>(); for (BugProperty prop = propertyListHead; prop != null; prop = prop.getNext()) { props.add(prop); } Collections.sort(props, (o1, o2) -> o1.getName().compareTo(o2.getName())); for (BugProperty prop : props) { prop.writeXML(xmlOutput); } } xmlOutput.closeTag(ELEMENT_NAME); } private int ageInDays(BugCollection bugCollection, long firstSeen) { long age = bugCollection.getAnalysisTimestamp() - firstSeen; if (age < 0) { age = 0; } int ageInDays = (int) (age / 1000 / 3600 / 24); return ageInDays; } /* * ---------------------------------------------------------------------- * Implementation * ---------------------------------------------------------------------- */ public BugInstance addOptionalAnnotation(@CheckForNull BugAnnotation annotation) { if (annotation == null) { return this; } return add(annotation); } public BugInstance addOptionalAnnotation(@CheckForNull BugAnnotation annotation, String role) { if (annotation == null) { return this; } return add(annotation).describe(role); } private void addJavaAnnotationNames(BugAnnotation annotation) { try { IAnalysisCache analysisCache = Global.getAnalysisCache(); if (analysisCache == null) { // Note: IAnalysisCache is not available during testing or spotbugs:gui return; } PackageMemberAnnotation pma = (PackageMemberAnnotation) annotation; ClassDescriptor classDescriptor = pma.getClassDescriptor(); ClassContext classContext = analysisCache.getClassAnalysis(ClassContext.class, classDescriptor); JavaClass javaClass = classContext.getJavaClass(); AnnotationEntry[] annotationEntries = javaClass.getAnnotationEntries(); List javaAnnotationNames = Arrays.asList(annotationEntries).stream().map((AnnotationEntry ae) -> { // map annotation entry type to dotted class name, for example // Lorg/immutables/value/Generated; -> org.immutables.value.Generated String annotationType = ae.getAnnotationType().substring(1).replace("/", ".").replace(";", ""); return annotationType; }).collect(Collectors.toList()); pma.setJavaAnnotationNames(javaAnnotationNames); } catch (Exception e) { LOG.debug(e.getMessage(), e); } } public BugInstance add(@Nonnull BugAnnotation annotation) { requireNonNull(annotation, "Missing BugAnnotation!"); // The java annotations for the class were not stored before, // thus we add a post-hook to lookup the java annotations for // bug annotation types that have a class descriptor. Then // post-analysis matcher can easily filter based on the java // annotations (without having to look at the bytecode again). if (annotation instanceof PackageMemberAnnotation) { addJavaAnnotationNames(annotation); } // Add to list annotationList.add(annotation); // This object is being modified, so the cached hashcode // must be invalidated cachedHashCode = INVALID_HASH_CODE; return this; } public BugInstance addSomeSourceForTopTwoStackValues(ClassContext classContext, Method method, Location location) { int pc = location.getHandle().getPosition(); try { OpcodeStack stack = OpcodeStackScanner.getStackAt(classContext.getJavaClass(), method, pc); BugAnnotation a1 = getSomeSource(classContext, method, location, stack, 1); BugAnnotation a0 = getSomeSource(classContext, method, location, stack, 0); addOptionalUniqueAnnotations(a0, a1); } catch (UnreachableCodeException e) { if (SystemProperties.ASSERTIONS_ENABLED) { AnalysisContext.logError(e.getMessage(), e); } assert true; } return this; } public BugInstance addSourceForTopStackValue(ClassContext classContext, Method method, Location location) { BugAnnotation b = getSourceForTopStackValue(classContext, method, location); return this.addOptionalAnnotation(b); } public static @CheckForNull BugAnnotation getSourceForTopStackValue(ClassContext classContext, Method method, Location location) { return getSourceForStackValue(classContext, method, location, 0); } public static @CheckForNull BugAnnotation getSourceForStackValue(ClassContext classContext, Method method, Location location, int depth) { try { int pc = location.getHandle().getPosition(); OpcodeStack stack = OpcodeStackScanner.getStackAt(classContext.getJavaClass(), method, pc); BugAnnotation a0 = getSomeSource(classContext, method, location, stack, depth); return a0; } catch (UnreachableCodeException e) { if (SystemProperties.ASSERTIONS_ENABLED) { AnalysisContext.logError(e.getMessage(), e); } return null; } } public static @CheckForNull BugAnnotation getSomeSource(ClassContext classContext, Method method, Location location, OpcodeStack stack, int stackPos) { if (stack.isTop()) { return null; } int pc = location.getHandle().getPosition(); try { BugAnnotation result = ValueNumberSourceInfo.getFromValueNumber(classContext, method, location, stackPos); if (result != null) { return result; } } catch (DataflowAnalysisException e) { AnalysisContext.logError("Couldn't find value source", e); } catch (CFGBuilderException e) { AnalysisContext.logError("Couldn't find value source", e); } return getValueSource(stack.getStackItem(stackPos), method, pc); } public static @CheckForNull BugAnnotation getValueSource(OpcodeStack.Item item, Method method, int pc) { LocalVariableAnnotation lv = LocalVariableAnnotation.getLocalVariableAnnotation(method, item, pc); if (lv != null && lv.isNamed()) { return lv; } BugAnnotation a = getFieldOrMethodValueSource(item); if (a != null) { return a; } Object c = item.getConstant(); if (c instanceof String) { a = new StringAnnotation((String) c); a.setDescription(StringAnnotation.STRING_CONSTANT_ROLE); return a; } if (c instanceof Integer && !item.isArray()) { a = new IntAnnotation((Integer) c); a.setDescription(IntAnnotation.INT_VALUE); return a; } return null; } public BugInstance addValueSource(@CheckForNull OpcodeStack.Item item, DismantleBytecode dbc) { if (item != null) { addValueSource(item, dbc.getMethod(), dbc.getPC()); } return this; } public BugInstance addValueSource(OpcodeStack.Item item, Method method, int pc) { addOptionalAnnotation(getValueSource(item, method, pc)); return this; } public BugInstance addFieldOrMethodValueSource(OpcodeStack.Item item) { addOptionalAnnotation(getFieldOrMethodValueSource(item)); return this; } public BugInstance addOptionalUniqueAnnotations(BugAnnotation... annotations) { HashSet added = new HashSet<>(); for (BugAnnotation a : annotations) { if (a != null && added.add(a)) { add(a); } } return this; } public boolean tryAddingOptionalUniqueAnnotations(BugAnnotation... annotations) { HashSet added = new HashSet<>(); for (BugAnnotation a : annotations) { if (a != null && added.add(a)) { add(a); } } return !added.isEmpty(); } public BugInstance addOptionalUniqueAnnotationsWithFallback(BugAnnotation fallback, BugAnnotation... annotations) { HashSet added = new HashSet<>(); for (BugAnnotation a : annotations) { if (a != null && added.add(a)) { add(a); } } if (added.isEmpty()) { add(fallback); } return this; } public static @CheckForNull BugAnnotation getFieldOrMethodValueSource(@CheckForNull OpcodeStack.Item item) { if (item == null) { return null; } XField xField = item.getXField(); if (xField != null) { FieldAnnotation a = FieldAnnotation.fromXField(xField); a.setDescription(FieldAnnotation.LOADED_FROM_ROLE); return a; } XMethod xMethod = item.getReturnValueOf(); if (xMethod != null) { MethodAnnotation a = MethodAnnotation.fromXMethod(xMethod); a.setDescription(MethodAnnotation.METHOD_RETURN_VALUE_OF); return a; } return null; } private void addSourceLinesForMethod(MethodAnnotation methodAnnotation, SourceLineAnnotation sourceLineAnnotation) { if (sourceLineAnnotation != null) { // Note: we don't add the source line annotation directly to // the bug instance. Instead, we stash it in the MethodAnnotation. // It is much more useful there, and it would just be distracting // if it were displayed in the UI, since it would compete for // attention // with the actual bug location source line annotation (which is // much // more important and interesting). methodAnnotation.setSourceLines(sourceLineAnnotation); } } @Override public int hashCode() { if (cachedHashCode == INVALID_HASH_CODE) { int hashcode = type.hashCode() + priority; Iterator i = annotationIterator(); while (i.hasNext()) { hashcode += i.next().hashCode(); } if (hashcode == INVALID_HASH_CODE) { hashcode = INVALID_HASH_CODE + 1; } cachedHashCode = hashcode; } return cachedHashCode; } @Override public boolean equals(Object o) { if (this == o) { return true; } if (!(o instanceof BugInstance)) { return false; } BugInstance other = (BugInstance) o; if (!type.equals(other.type) || priority != other.priority) { return false; } if (annotationList.size() != other.annotationList.size()) { return false; } int numAnnotations = annotationList.size(); for (int i = 0; i < numAnnotations; ++i) { BugAnnotation lhs = annotationList.get(i); BugAnnotation rhs = other.annotationList.get(i); if (!lhs.equals(rhs)) { return false; } } return true; } @Override public int compareTo(BugInstance other) { int cmp; cmp = type.compareTo(other.type); if (cmp != 0) { return cmp; } cmp = priority - other.priority; if (cmp != 0) { return cmp; } // Compare BugAnnotations lexicographically int pfxLen = Math.min(annotationList.size(), other.annotationList.size()); for (int i = 0; i < pfxLen; ++i) { BugAnnotation lhs = annotationList.get(i); BugAnnotation rhs = other.annotationList.get(i); cmp = lhs.compareTo(rhs); if (cmp != 0) { return cmp; } } // All elements in prefix were the same, // so use number of elements to decide return annotationList.size() - other.annotationList.size(); } public void setFirstVersion(long firstVersion) { if (lastVersion >= 0 && firstVersion > lastVersion) { throw new IllegalArgumentException(firstVersion + ".." + lastVersion); } this.firstVersion = firstVersion; } public void clearHistory() { setFirstVersion(0); setLastVersion(-1); setIntroducedByChangeOfExistingClass(false); setRemovedByChangeOfPersistingClass(false); } public long getFirstVersion() { return firstVersion; } public void setHistory(BugInstance from) { long first = from.getFirstVersion(); long last = from.getLastVersion(); if (first > 0 && last >= 0 && first > last) { throw new IllegalArgumentException("from has version range " + first + "..." + last + " in " + from.getBugPattern() + "\n" + from.getMessage()); } setFirstVersion(first); setLastVersion(last); this.removedByChangeOfPersistingClass = from.removedByChangeOfPersistingClass; this.introducedByChangeOfExistingClass = from.introducedByChangeOfExistingClass; } public void setLastVersion(long lastVersion) { if (lastVersion >= 0 && firstVersion > lastVersion) { throw new IllegalArgumentException(firstVersion + ".." + lastVersion); } this.lastVersion = lastVersion; } /** Mark the bug instance is being alive (still present in the last version) */ public void setLive() { this.lastVersion = -1; } public long getLastVersion() { return lastVersion; } public boolean isDead() { return lastVersion != -1; } public void setIntroducedByChangeOfExistingClass(boolean introducedByChangeOfExistingClass) { this.introducedByChangeOfExistingClass = introducedByChangeOfExistingClass; } public boolean isIntroducedByChangeOfExistingClass() { return introducedByChangeOfExistingClass; } public void setRemovedByChangeOfPersistingClass(boolean removedByChangeOfPersistingClass) { this.removedByChangeOfPersistingClass = removedByChangeOfPersistingClass; } public boolean isRemovedByChangeOfPersistingClass() { return removedByChangeOfPersistingClass; } public void setInstanceHash(String instanceHash) { this.instanceHash = instanceHash; } public void setOldInstanceHash(String oldInstanceHash) { this.oldInstanceHash = oldInstanceHash; } public String getInstanceHash() { String hash = instanceHash; if (hash != null) { return hash; } MessageDigest digest = Util.getMD5Digest(); String key = getInstanceKey(); byte[] data; data = digest.digest(key.getBytes(StandardCharsets.UTF_8)); hash = new BigInteger(1, data).toString(16); instanceHash = hash; return hash; } public boolean isInstanceHashConsistent() { return oldInstanceHash == null || getInstanceHash().equals(oldInstanceHash); } public void setInstanceOccurrenceNum(int instanceOccurrenceNum) { this.instanceOccurrenceNum = instanceOccurrenceNum; } public int getInstanceOccurrenceNum() { return instanceOccurrenceNum; } public void setInstanceOccurrenceMax(int instanceOccurrenceMax) { this.instanceOccurrenceMax = instanceOccurrenceMax; } public int getInstanceOccurrenceMax() { return instanceOccurrenceMax; } @CheckForNull public DetectorFactory getDetectorFactory() { return detectorFactory; } private void optionalAdd(Collection c, BugAnnotation a) { if (a != null) { c.add(a); } } public List getAnnotationsForMessage(boolean showContext) { ArrayList result = new ArrayList<>(); HashSet primaryAnnotations = new HashSet<>(); // This ensures the order of the primary annotations of the bug FieldAnnotation primeField = getPrimaryField(); MethodAnnotation primeMethod = getPrimaryMethod(); ClassAnnotation primeClass = getPrimaryClass(); SourceLineAnnotation primarySourceLineAnnotation = getPrimarySourceLineAnnotation(); optionalAdd(primaryAnnotations, primarySourceLineAnnotation); optionalAdd(primaryAnnotations, primeMethod); optionalAdd(primaryAnnotations, primeField); optionalAdd(primaryAnnotations, primeClass); if ((showContext || !SourceLineAnnotation.DEFAULT_ROLE.equals(primarySourceLineAnnotation.getDescription()))) { result.add(primarySourceLineAnnotation); } if (primeMethod != null && (showContext || !MethodAnnotation.DEFAULT_ROLE.equals(primeMethod.getDescription()))) { result.add(primeMethod); } optionalAdd(result, primeField); String fieldClass = ""; String methodClass = ""; if (primeField != null) { fieldClass = primeField.getClassName(); } if (primeMethod != null) { methodClass = primeMethod.getClassName(); } if (showContext && (primaryAnnotations.size() < 2) || (!(primeClass.getClassName().equals(fieldClass) || primeClass.getClassName().equals(methodClass)))) { optionalAdd(result, primeClass); } for (BugAnnotation b : getAnnotations()) { if (primaryAnnotations.contains(b)) { continue; } if (b instanceof LocalVariableAnnotation && !((LocalVariableAnnotation) b).isNamed()) { continue; } if (b instanceof SourceLineAnnotation && ((SourceLineAnnotation) b).isUnknown()) { continue; } result.add(b); } return result; } }