Bug patterns

This list is auto-generated from our sources. Each bug pattern includes code examples of both positive and negative cases; these examples are used in our regression test suite.

Patterns which are marked Experimental will not be evaluated against your code, unless you specifically configure Error Prone. The default checks are marked On by default, and each release promotes some experimental checks after we’ve vetted them against Google’s codebase.

On by default : ERROR

AndroidInjectionBeforeSuper
AndroidInjection.inject() should always be invoked before calling super.lifecycleMethod()

ArrayEquals
Reference equality used to compare arrays

ArrayFillIncompatibleType
Arrays.fill(Object[], Object) called with incompatible types.

ArrayHashCode
hashcode method on array does not hash array contents

ArrayToString
Calling toString on an array does not provide useful information

ArraysAsListPrimitiveArray
Arrays.asList does not autobox primitive arrays, as one might expect.

AsyncCallableReturnsNull
AsyncCallable should not return a null Future, only a Future whose result is null.

AsyncFunctionReturnsNull
AsyncFunction should not return a null Future, only a Future whose result is null.

AutoValueConstructorOrderChecker
Arguments to AutoValue constructor are in the wrong order

BadShiftAmount
Shift by an amount that is out of range

BundleDeserializationCast
Object serialized in Bundle may have been flattened to base type.

ChainingConstructorIgnoresParameter
The called constructor accepts a parameter with the same name and type as one of its caller's parameters, but its caller doesn't pass that parameter to it. It's likely that it was intended to.

CheckReturnValue
Ignored return value of method that is annotated with @CheckReturnValue

CollectionIncompatibleType
Incompatible type as argument to Object-accepting Java collections method

ComparisonOutOfRange
Comparison to value that is out of range for the compared type

CompatibleWithAnnotationMisuse
@CompatibleWith's value is not a type argument.

CompileTimeConstant
Non-compile-time constant expression passed to parameter with @CompileTimeConstant type annotation.

ComplexBooleanConstant
Non-trivial compile time constant boolean expressions shouldn't be used.

ConstantOverflow
Compile-time constant expression overflows

DaggerProvidesNull
Dagger @Provides methods may not return null unless annotated with @Nullable

DeadException
Exception created but not thrown

DeadThread
Thread created but not started

DoNotCall
This method should not be called.

EqualsNaN
== NaN always returns false; use the isNaN methods instead

EqualsReference
== must be used in equals method to check equality to itself or an infinite loop will occur.

FilesLinesLeak
The stream returned by Files.lines should be closed using try-with-resources

ForOverride
Method annotated @ForOverride must be protected or package-private and only invoked from declaring class, or from an override of the method

FormatString
Invalid printf-style format string

FormatStringAnnotation
Invalid format string passed to formatting method.

FunctionalInterfaceMethodChanged
Casting a lambda to this @FunctionalInterface can cause a behavior change from casting to a functional superinterface, which is surprising to users. Prefer decorator methods to this surprising behavior.

FuturesGetCheckedIllegalExceptionType
Futures.getChecked requires a checked exception type with a standard constructor.

GetClassOnAnnotation
Calling getClass() on an annotation may return a proxy class

GetClassOnClass
Calling getClass() on an object of type Class returns the Class object for java.lang.Class; you probably meant to operate on the object directly

GuardedBy
Checks for unguarded accesses to fields and methods with @GuardedBy annotations

GuiceAssistedInjectScoping
Scope annotation on implementation class of AssistedInject factory is not allowed

GuiceAssistedParameters
A constructor cannot have two @Assisted parameters of the same type unless they are disambiguated with named @Assisted annotations.

GuiceInjectOnFinalField
Although Guice allows injecting final fields, doing so is disallowed because the injected value may not be visible to other threads.

HashtableContains
contains() is a legacy method that is equivalent to containsValue()

IdentityBinaryExpression
A binary expression where both operands are the same is usually incorrect.

Immutable
Type declaration annotated with @Immutable is not immutable

ImmutableModification
Modifying an immutable collection is guaranteed to throw an exception and leave the collection unmodified

IncompatibleArgumentType
Passing argument to a generic method with an incompatible type.

IndexOfChar
The first argument to indexOf is a Unicode code point, and the second is the index to start the search from

InexactVarargsConditional
Conditional expression in varargs call contains array and non-array arguments

InfiniteRecursion
This method always recurses, and will cause a StackOverflowError

InjectMoreThanOneScopeAnnotationOnClass
A class can be annotated with at most one scope annotation.

InvalidPatternSyntax
Invalid syntax used for a regular expression

InvalidTimeZoneID
Invalid time zone identifier. TimeZone.getTimeZone(String) will silently return GMT instead of the time zone you intended.

IsInstanceOfClass
The argument to Class#isInstance(Object) should not be a Class

IsLoggableTagLength
Log tag too long, cannot exceed 23 characters.

JUnit3TestNotRun
Test method will not be run; please correct method signature (Should be public, non-static, and method name should begin with "test").

JUnit4ClassAnnotationNonStatic
This method should be static

JUnit4SetUpNotRun
setUp() method will not be run; Please add a @Before annotation

JUnit4TearDownNotRun
tearDown() method will not be run; Please add an @After annotation

JUnit4TestNotRun
This looks like a test method but is not run; please add @Test or @Ignore, or, if this is a helper method, reduce its visibility.

JUnitAssertSameCheck
An object is tested for reference equality to itself using JUnit library.

JavaxInjectOnAbstractMethod
Abstract and default methods are not injectable with javax.inject.Inject

LiteByteStringUtf8
This pattern will silently corrupt certain byte sequences from the serialized protocol message. Use ByteString or byte[] directly

LoopConditionChecker
Loop condition is never modified in loop body.

MislabeledAndroidString
Certain resources in android.R.string have names that do not match their content

MissingSuperCall
Overriding method is missing a call to overridden super method

MisusedWeekYear
Use of "YYYY" (week year) in a date pattern without "ww" (week in year). You probably meant to use "yyyy" (year) instead.

MockitoCast
A bug in Mockito will cause this test to fail at runtime with a ClassCastException

MockitoUsage
Missing method call for verify(mock) here

ModifyingCollectionWithItself
Using a collection function with itself as the argument.

MoreThanOneInjectableConstructor
This class has more than one @Inject-annotated constructor. Please remove the @Inject annotation from all but one of them.

MustBeClosedChecker
The result of this method must be closed.

NCopiesOfChar
The first argument to nCopies is the number of copies, and the second is the item to copy

NonCanonicalStaticImport
Static import of type uses non-canonical name

NonFinalCompileTimeConstant
@CompileTimeConstant parameters should be final or effectively final

NonRuntimeAnnotation
Calling getAnnotation on an annotation that is not retained at runtime.

NullTernary
This conditional expression may evaluate to null, which will result in an NPE when the result is unboxed.

OptionalEquality
Comparison using reference equality instead of value equality

OverlappingQualifierAndScopeAnnotation
Annotations cannot be both Scope annotations and Qualifier annotations: this causes confusion when trying to use them.

OverridesJavaxInjectableMethod
This method is not annotated with @Inject, but it overrides a method that is annotated with @javax.inject.Inject. The method will not be Injected.

PackageInfo
Declaring types inside package-info.java files is very bad form

PreconditionsCheckNotNull
Literal passed as first argument to Preconditions.checkNotNull() can never be null

PreconditionsCheckNotNullPrimitive
First argument to Preconditions.checkNotNull() is a primitive rather than an object reference

PredicateIncompatibleType
Using ::equals as an incompatible Predicate; the predicate will always return false

PrivateSecurityContractProtoAccess
Access to a private protocol buffer field is forbidden. This protocol buffer carries a security contract, and can only be created using an approved library. Direct access to the fields is forbidden.

ProtoFieldNullComparison
Protobuf fields cannot be null

ProtocolBufferOrdinal
To get the tag number of a protocol buffer enum, use getNumber() instead.

ProvidesMethodOutsideOfModule
@Provides methods need to be declared in a Module to have any effect.

RandomModInteger
Use Random.nextInt(int). Random.nextInt() % n can have negative results

RectIntersectReturnValueIgnored
Return value of android.graphics.Rect.intersect() must be checked

RestrictTo
Use of method or class annotated with @RestrictTo

RestrictedApiChecker
Check for non-whitelisted callers to RestrictedApiChecker.

ReturnValueIgnored
Return value of this method must be used

SelfAssignment
Variable assigned to itself

SelfComparison
An object is compared to itself

SelfEquals
Testing an object for equality with itself will always be true.

ShouldHaveEvenArgs
This method must be called with an even number of arguments.

SizeGreaterThanOrEqualsZero
Comparison of a size >= 0 is always true, did you intend to check for non-emptiness?

StreamToString
Calling toString on a Stream does not provide useful information

StringBuilderInitWithChar
StringBuilder does not have a char constructor; this invokes the int constructor.

SuppressWarningsDeprecated
Suppressing "deprecated" is probably a typo for "deprecation"

ThrowIfUncheckedKnownChecked
throwIfUnchecked(knownCheckedException) is a no-op.

ThrowNull
Throwing 'null' always results in a NullPointerException being thrown.

TruthSelfEquals
isEqualTo should not be used to test an object for equality with itself; the assertion will never fail.

TryFailThrowable
Catching Throwable/Error masks failures from fail() or assert*() in the try block

TypeParameterQualifier
Type parameter used as type qualifier

UnnecessaryTypeArgument
Non-generic methods should not be invoked with type arguments

UnusedAnonymousClass
Instance created but never used

UnusedCollectionModifiedInPlace
Collection is modified in place, but the result is not used

On by default : WARNING

AmbiguousMethodReference
Method reference is ambiguous

ArgumentSelectionDefectChecker
Arguments are in the wrong order or could be commented for clarity.

AssertEqualsArgumentOrderChecker
Arguments are swapped in assertEquals-like call

AssertionFailureIgnored
This assertion throws an AssertionError if it fails, which will be caught by an enclosing try block.

BadAnnotationImplementation
Classes that implement Annotation must override equals and hashCode. Consider using AutoAnnotation instead of implementing Annotation by hand.

BadComparable
Possible sign flip from narrowing conversion

BoxedPrimitiveConstructor
valueOf or autoboxing provides better time and space performance

CannotMockFinalClass
Mockito cannot mock final classes

CanonicalDuration
Duration can be expressed more clearly with different units

ClassCanBeStatic
Inner class is non-static but does not reference enclosing class

ClassNewInstance
Class.newInstance() bypasses exception checking; prefer getDeclaredConstructor().newInstance()

CollectionToArraySafeParameter
The type of the array parameter of Collection.toArray needs to be compatible with the array type

CollectorShouldNotUseState
Collector.of() should not use state

ComparableAndComparator
Class should not implement both Comparable and Comparator

DefaultCharset
Implicit use of the platform default charset, which can result in e.g. non-ASCII characters being silently replaced with '?' in many environments

DoubleCheckedLocking
Double-checked locking on non-volatile fields is unsafe

EqualsHashCode
Classes that override equals should also override hashCode.

EqualsIncompatibleType
An equality test between objects with incompatible types always returns false

FallThrough
Switch case may fall through

Finally
If you return or throw from a finally, then values returned or thrown from the try-catch block will be ignored. Consider using try-with-resources instead.

FloatCast
Use parenthesis to make the precedence explicit

FloatingPointLiteralPrecision
Floating point literal loses precision

FragmentInjection
Classes extending PreferenceActivity must implement isValidFragment such that it does not unconditionally return true to prevent vulnerability to fragment injection attacks.

FragmentNotInstantiable
Subclasses of Fragment must be instantiable via Class#newInstance(): the class must be public, static and have a public nullary constructor

FunctionalInterfaceClash
Overloads will be ambiguous when passing lambda arguments

FutureReturnValueIgnored
Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.

GetClassOnEnum
Calling getClass() on an enum may return a subclass of the enum type

HidingField
Hiding fields of superclasses may cause confusion and errors

ImmutableAnnotationChecker
Annotations should always be immutable

ImmutableEnumChecker
Enums should always be immutable

IncompatibleModifiers
This annotation has incompatible modifiers as specified by its @IncompatibleModifiers annotation

IncrementInForLoopAndHeader
This for loop increments the same variable in the header and in the body

InjectOnConstructorOfAbstractClass
Constructors on abstract classes are never directly @Injected, only the constructors of their subclasses can be @Inject'ed.

InputStreamSlowMultibyteRead
Please also override int read(byte[], int, int), otherwise multi-byte reads from this input stream are likely to be slow.

InstanceOfAndCastMatchWrongType
Casting inside an if block should be plausibly consistent with the instanceof type

IntLongMath
Expression of type int may overflow before being assigned to a long

IterableAndIterator
Class should not implement both Iterable and Iterator

JUnit3FloatingPointComparisonWithoutDelta
Floating-point comparison without error tolerance

JUnit4ClassUsedInJUnit3
Some JUnit4 construct cannot be used in a JUnit3 context. Convert your class to JUnit4 style to use them.

JUnitAmbiguousTestClass
Test class inherits from JUnit 3's TestCase but has JUnit 4 @Test annotations.

JavaLangClash
Never reuse class names from java.lang

JdkObsolete
Suggests alternatives to obsolete JDK classes.

LogicalAssignment
Assignment where a boolean expression was expected; use == if this assignment wasn't expected or add parentheses for clarity.

MissingCasesInEnumSwitch
Switches on enum types should either handle all values, or have a default case.

MissingFail
Not calling fail() when expecting an exception masks bugs

MissingOverride
method overrides method in supertype; expected @Override

MultipleParallelOrSequentialCalls
Multiple calls to either parallel or sequential are unnecessary and cause confusion.

MutableConstantField
Constant field declarations should use the immutable type (such as ImmutableList) instead of the general collection interface type (such as List)

NamedParameters
Parameter name in argument comment is incorrect

NarrowingCompoundAssignment
Compound assignments may hide dangerous casts

NestedInstanceOfConditions
Nested instanceOf conditions of disjoint types create blocks of code that never execute

NonAtomicVolatileUpdate
This update of a volatile variable is non-atomic

NonOverridingEquals
equals method doesn't override Object.equals

NullableConstructor
Constructors should not be annotated with @Nullable since they cannot return null

NullablePrimitive
@Nullable should not be used for primitive types since they cannot be null

NullableVoid
void-returning methods should not be annotated with @Nullable, since they cannot return null

OperatorPrecedence
Use grouping parenthesis to make the operator precedence explicit

OptionalNotPresent
One should not call optional.get() inside an if statement that checks !optional.isPresent

OverrideThrowableToString
To return a custom message with a Throwable class, one should override getMessage() instead of toString() for Throwable.

Overrides
Varargs doesn't agree for overridden method

OverridesGuiceInjectableMethod
This method is not annotated with @Inject, but it overrides a method that is annotated with @com.google.inject.Inject. Guice will inject this method, and it is recommended to annotate it explicitly.

ParameterName
Detects /* name= */-style comments on actual parameters where the name doesn't match the formal parameter

PreconditionsInvalidPlaceholder
Preconditions only accepts the %s placeholder in error message strings

ProtoFieldPreconditionsCheckNotNull
Protobuf fields cannot be null, so this check is redundant

ReferenceEquality
Comparison using reference equality instead of value equality

RequiredModifiers
This annotation is missing required modifiers as specified by its @RequiredModifiers annotation

ShortCircuitBoolean
Prefer the short-circuiting boolean operators && and || to & and |.

SimpleDateFormatConstant
SimpleDateFormat is not thread-safe, and should not be used as a constant field.

StaticGuardedByInstance
Writes to static fields should not be guarded by instance locks

SynchronizeOnNonFinalField
Synchronizing on non-final fields is not safe: if the field is ever updated, different threads may end up locking on different objects.

ThreadJoinLoop
Thread.join needs to be surrounded by a loop until it succeeds, as in Uninterruptibles.joinUninterruptibly.

TruthConstantAsserts
Truth Library assert is called on a constant.

TypeParameterShadowing
Type parameter declaration overrides another type parameter already declared

TypeParameterUnusedInFormals
Declaring a type parameter that is only used in the return type is a misuse of generics: operations on the type parameter are unchecked, it hides unsafe casts at invocations of the method, and it interacts badly with method overload resolution.

URLEqualsHashCode
Creation of a Set/HashSet/HashMap of java.net.URL. equals() and hashCode() of java.net.URL class make blocking internet connections.

UnsafeFinalization
Finalizer may run before native code finishes execution

UnsynchronizedOverridesSynchronized
Unsynchronized method overrides a synchronized method.

UseCorrectAssertInTests
Java assert is used in test. For testing purposes Assert.* matchers should be used.

WaitNotInLoop
Because of spurious wakeups, Object.wait() and Condition.await() must always be called in a loop

WakelockReleasedDangerously
A wakelock acquired with a timeout may be released by the system before calling release, even after checking isHeld(). If so, it will throw a RuntimeException. Please wrap in a try/catch block.

Experimental : ERROR

AssistedInjectAndInjectOnSameConstructor
@AssistedInject and @Inject cannot be used on the same constructor.

AutoFactoryAtInject
@AutoFactory and @Inject should not be used in the same type.

ClassName
The source file name should match the name of the top-level class it contains

ComparisonContractViolated
This comparison method violates the contract

DepAnn
Deprecated item is not annotated with @Deprecated

DivZero
Division by integer literal zero

EmptyIf
Empty statement after if

FuzzyEqualsShouldNotBeUsedInEqualsMethod
DoubleMath.fuzzyEquals should never be used in an Object.equals() method

InjectInvalidTargetingOnScopingAnnotation
A scoping annotation's Target should include TYPE and METHOD.

InjectMoreThanOneQualifier
Using more than one qualifier annotation on the same element is not allowed.

InjectScopeAnnotationOnInterfaceOrAbstractClass
Scope annotation on an interface or abstact class is not allowed

InjectScopeOrQualifierAnnotationRetention
Scoping and qualifier annotations must have runtime retention.

InjectedConstructorAnnotations
Injected constructors cannot be optional nor have binding annotations

InsecureCryptoUsage
A standard cryptographic operation is used in a mode that is prone to vulnerabilities

IterablePathParameter
Path implements Iterable<Path>; prefer Collection<Path> for clarity

JMockTestWithoutRunWithOrRuleAnnotation
jMock tests must have a @RunWith(JMock.class) annotation, or the Mockery field must have a @Rule JUnit annotation

JavaxInjectOnFinalField
@javax.inject.Inject cannot be put on a final field.

LockMethodChecker
This method does not acquire the locks specified by its @LockMethod annotation

LongLiteralLowerCaseSuffix
Prefer 'L' to 'l' for the suffix to long literals

NoAllocation
@NoAllocation was specified on this method, but something was found that would trigger an allocation

NumericEquality
Numeric comparison using reference equality instead of value equality

ParameterPackage
Method parameter has wrong package

ProtoStringFieldReferenceEquality
Comparing protobuf fields of type String using reference equality

QualifierOrScopeOnInjectMethod
Qualifiers/Scope annotations on @Inject methods don't have any effect. Move the qualifier annotation to the binding location.

StaticOrDefaultInterfaceMethod
Static and default interface methods are not natively supported on older Android devices.

UnlockMethod
This method does not acquire the locks specified by its @UnlockMethod annotation

Experimental : WARNING

AssertFalse
Assertions may be disabled at runtime and do not guarantee that execution will halt here; consider throwing an exception instead

AssistedInjectAndInjectOnConstructors
@AssistedInject and @Inject should not be used on different constructors in the same class.

BigDecimalLiteralDouble
BigDecimal(double) and BigDecimal.valueOf(double) may lose precision, prefer BigDecimal(String) or BigDecimal(long)

BindingToUnqualifiedCommonType
This code declares a binding for a common value type without a Qualifier annotation.

ConstructorInvokesOverridable
Constructors should not invoke overridable methods.

ConstructorLeaksThis
Constructors should not pass the 'this' reference out in method invocations, since the object may not be fully constructed.

EmptyTopLevelDeclaration
Empty top-level type declaration

ExpectedExceptionChecker
Calls to ExpectedException#expect should always be followed by exactly one statement.

HardCodedSdCardPath
Hardcoded reference to /sdcard

InconsistentOverloads
The ordering of parameters in overloaded methods should be as consistent as possible (when viewed from left to right)

MissingDefault
The Google Java Style Guide requires that each switch statement includes a default statement group, even if it contains no code. (This requirement is lifted for any switch statement that covers all values of an enum.)

MutableMethodReturnType
Method return type should use the immutable type (such as ImmutableList) instead of the general collection interface type (such as List)

NonCanonicalStaticMemberImport
Static import of member uses non-canonical name

PrimitiveArrayPassedToVarargsMethod
Passing a primitive array to a varargs method is usually wrong

ProvidesFix
BugChecker has incorrect ProvidesFix tag, please update

QualifierWithTypeUse
Injection frameworks currently don't understand Qualifiers in TYPE_PARAMETER or TYPE_USE contexts.

RedundantThrows
Thrown exception is a subtype of another

StaticQualifiedUsingExpression
A static variable or method should be qualified with a class name, not expression

StringEquality
String comparison using reference equality instead of value equality

TestExceptionChecker
Using @Test(expected=…) is discouraged, since the test will pass if any statement in the test method throws the expected exception

UnnecessaryDefaultInEnumSwitch
Switch handles all enum values; an explicit default case is unnecessary and defeats error checking for non-exhaustive switches.

Var
Non-constant variable missing @Var annotation

Experimental : SUGGESTION

BooleanParameter
Use parameter comments to document ambiguous literals

ConstantField
Field name is CONSTANT_CASE, but field is not static and final

EmptySetMultibindingContributions
@Multibinds is a more efficient and declarative mechanism for ensuring that a set multibinding is present in the graph.

FieldMissingNullable
Fields that can be null should be annotated @Nullable

MethodCanBeStatic
A private method that does not reference the enclosing instance can be static

MixedArrayDimensions
C-style array declarations should not be used

MultiVariableDeclaration
Variable declarations should declare only one variable

MultipleTopLevelClasses
Source files should not contain multiple top-level class declarations

MultipleUnaryOperatorsInMethodCall
Avoid having multiple unary operators acting on the same variable in a method call

PackageLocation
Package names should match the directory they are declared in

ParameterComment
Non-standard parameter comment; prefer /*paramName=*/ arg

ParameterNotNullable
Method parameters that aren't checked for null shouldn't be annotated @Nullable

PrivateConstructorForNoninstantiableModuleTest
Add a private constructor to modules that will not be instantiated by Dagger.

PrivateConstructorForUtilityClass
Utility classes (only static members) are not designed to be instantiated and should be made noninstantiable with a default constructor.

RemoveUnusedImports
Unused imports

ReturnMissingNullable
Methods that can return null should be annotated @Nullable

ThrowsUncheckedException
Unchecked exceptions do not need to be declared in the method signature.

UngroupedOverloads
Constructors and methods with the same name should appear sequentially with no other code in between

UnnecessarySetDefault
Unnecessary call to NullPointerTester#setDefault

UnnecessaryStaticImport
Using static imports for types is unnecessary

UseBinds
@Binds is a more efficient and declarative mechanism for delegating a binding.

WildcardImport
Wildcard imports, static or otherwise, should not be used