### Error messages for the Lock Checker
contracts.precondition=call to '%s' requires '%s' to be held
override.sideeffect=the side-effect annotation on an overrider method must be at least as strong as the one the overridden method.%nmethod in %s%n  %s%n  cannot override method in %s%n  %s
multiple.sideeffect.annotations=method is annotated with multiple side effect annotations
multiple.lock.precondition.annotations=only one @Holding, @net.jcip.annotations.GuardedBy or @javax.annotation.concurrent.GuardedBy annotation is allowed on a method
multiple.guardedby.annotations=only one @org.checkerframework.checker.lock.qual.GuardedBy, @net.jcip.annotations.GuardedBy or @javax.annotation.concurrent.GuardedBy annotation is allowed on a variable declaration
method.guarantee.violated=%s method %s calls method %s with a weaker %s side effect guarantee
cannot.dereference=cannot dereference expression %s with refined type annotation @%s
immutable.type.guardedby=immutable types need not be annotated with any qualifier from the @GuardedBy hierarchy
explicit.lock.synchronized=expression of synchronized block is an explicit lock
guardsatisfied.with.mayreleaselocks=a method annotated with @MayReleaseLocks may not have a formal parameter or receiver annotated with @GuardSatisfied
guardsatisfied.parameters.must.match=%s and %s on the declaration of method %s are both annotated with @GuardSatisfied(%s). However the corresponding annotations at the method call site are %s and %s, and neither is a subtype of the other.
guardsatisfied.return.must.have.index=@GuardSatisfied on a return type must use an index.
guardsatisfied.assignment.disallowed=Expressions %s and %s are both annotated with @GuardSatisfied. The guards for both expressions may be different, so the assignment is disallowed.
guardsatisfied.location.disallowed=@GuardSatisfied annotations are only allowed on method return types and parameters (including the receiver).
lockingfree.synchronized.method=A synchronized method cannot be %s. It may only be annotated with @ReleasesNoLocks or @MayReleaseLocks.
synchronized.block.in.lockingfree.method=A synchronized block cannot be written inside a %s method. It may only be written in a method annotated with @ReleasesNoLocks or @MayReleaseLocks.
lock.expression.not.final=lock expression includes a non-final field or a call to a method that is not pure or deterministic.%n lock expression: %s
lock.expression.possibly.not.final=could not determine that the lock expression(s) include only non-final fields or calls to methods that are pure or deterministic.%n lock expression: %s
lock.not.held=required lock not held.%nrequired: %s