Fixes `RedundantThrows` inspection violations.
Description:
>This inspection reports exceptions that are declared in a method's signature but never thrown by the method itself or its implementations/derivatives.
Fixes `AnonymousClassMethodCount` inspection violation.
Description:
>Reports anonymous inner class with too many methods. Anonymous classes with more than a very low number of methods may be difficult to understand, and should probably be promoted to become named inner classes.
Fixes `UnnecessaryToStringCall` inspection violations.
Description:
>Reports on any calls to toString() used in string concatenations and as arguments to the print() and println() methods of java.io.PrintWriter and java.io.PrintStream, the append() method of java.lang.StringBuilder and java.lang.StringBuffer or the trace(), debug(), info(), warn() and error() methods of org.slf4j.Logger. In these cases the conversion to string will be handled by the underlying library methods and an explicit call to toString() is no needed.
Note that without the toString() call the expression will have slightly different semantics (the string null will be used instead of throwing a NullPointerException).
Fixes `UnnecessaryEnumModifier` inspection violations.
Description:
>Reports on any redundant modifiers on enumerated classes or components of enumerated classes.
Fixes `UNCHECKED_WARNING` inspection violations.
Description:
>Unchecked overriding: return type requires unchecked conversion. Found 'java.lang.Object', required 'T' (at line 251).
Signals places where an unchecked warning is issued by the compiler, for example:
```
void f(HashMap map) {
map.put("key", "value");
}
```
Fixes `RedundantMethodOverride` inspection violation.
Description:
>Reports any method that has a body and signature that are identical to its super method. Such a method is redundant and probably a coding error.
Fixes `ConfusingElse` inspection violation.
Description:
>Reports confusing else branches. else branches are confusing when the if statement is followed by other statements and the if branch cannot complete normally, for example because it ends with a return statement. In these cases the statements in the else can be moved after the if statement and the else branch removed.
Fixes `ListenerMayUseAdapter` inspection violations.
Description:
>Reports any classes which implement a listener, but may extend the corresponding adapter instead. The quickfix for this inspection will also remove any redundant empty methods left over after replacing the implementation of the listener with an extension of the corresponding adapter.
Fixes `OverridableMethodCallDuringObjectConstruction` inspection violations.
Description:
>Reports any calls to overridable methods of the current class during object construction. A call is during object construction if it is made inside a constructor, in an non-static instance initializer, in a non-static field initializer or inside a clone(), readObject() or readObjectNoData() method. Methods are overridable if they are not declared final, static or private. Such calls may result in subtle bugs, as the object is not guaranteed to be initialized before the method call occurs.
Fixes `UseOfClone` inspection violation.
Description:
>Reports calls to and implementations of the clone() method and uses of java.lang.Cloneable. Some coding standards prohibit clone() usage, and recommend using a copy constructor or static factory method. Calls to clone() on arrays are ignored, because that is a common, correct, efficient and compact way to copy an array.
Fixes `ExceptionFromCatchWhichDoesntWrap` inspection violation.
Description:
>Reports exceptions constructed and thrown from inside catch blocks, which do not "wrap" the caught exception. It is considered good practice when throwing an exception in response to an exception to wrap the initial exception, so that valuable context information such as stack frames and line numbers are not lost.
Fixes `NonFinalUtilityClass` inspection violation.
Description:
>Reports utility classes which are not final. Utility classes have all fields and methods declared static. Giving such classes making them final prevents them from being inadvertently subclassed.
Fixes `JavaDoc` inspection violations.
Description:
>This inspection points out the following javadoc comment flaws:
- no javadoc where it is required
- required tag is missing
- invalid or incomplete tag
- javadoc description is missing or incomplete
Fixes `CanBeFinal` inspection violation.
Description:
>This inspection reports all fields, methods or classes, found in the specified inspection scope, that may have a final modifier added to their declarations.
Fixes `UnnecessaryJavaDocLink` inspection violations.
Description:
>Reports any Javadoc @see, {@link} and {@linkplain} tags which reference the method owning the comment, the super method of the method owning the comment or the class containing the comment. Such links are unnecessary and can be safely removed using this inspections quickfix. The quickfix will remove the entire Javadoc comment if the link is its only content.
Fixes `AbstractMethodOverridesAbstractMethod` inspection violations.
Description:
>Reports abstract methods which override abstract methods. Methods with different return types or exception declarations than the method they override are not reported by this inspection.
Fixes `NonProtectedConstructorInAbstractClass` inspection violations.
Description:
>Reports constructors in abstract classes that are not declared protected, package-protected or private.
Fixes `ConstantOnLHSOfComparison` inspection violations.
Description:
>Reports on comparison operations with constant values on their left-hand side. Some coding conventions specify that constants should be on the right-hand side of comparisons.
Fixes MagicConstant violations.
Description:
> Report occurrences where usages of "magic" constants only are allowed but other expressions are used instead. E.g. new Font("Arial", 2 ) // not allowed instead of new Font("Arial", Font. ITALIC ) // OK Please see org.intellij.lang.annotations.MagicConstant annotation description for details.
Fixes `BadExceptionThrown` inspection violations.
Description:
>Reports throw statements which throw inappropriate exceptions. One use of this inspection would be to warn of throw statements which throw overly generic exceptions (e.g. java.lang.Exception or java.io.IOException).
Fixes `ThrowsRuntimeException` inspection violation.
Description:
Reports declarations of unchecked exceptions (RuntimeException and its subclasses) in the throws clause of a method. Declaration of unchecked exceptions are not required and may be removed or moved to a Javadoc @throws tag.
Fixes `UnusedCatchParameter` inspection violations.
Description:
Reports any catch parameters that are unused in their corresponding blocks. This inspection will not report any catch parameters named "ignore" or "ignored". Conversely this inspection will warn on any catch parameters named "ignore" or "ignored" that are actually used.
Fixes `StringReplaceableByStringBuffer` inspection violations.
Description:
Reports any variables declared as java.lang.String which are repeatedly appended to. Such variables may be more efficiently declared as java.lang.StringBuffer or java.lang.StringBuilder.
Fixes `MethodMayBeStatic` inspection violation.
Description:
>Reports any methods which may safely be made static. A method may be static if it is not synchronized, it does not reference any of its class' non static methods and non static fields and is not overridden in a sub class.
Fixes `Simplify empty string check` inspection violations.
Description:
>Reports .equals() being called to compare a String with an empty string. It is normally more performant to test a String for emptiness by comparing its .length() to zero instead.
Fixes `ToArrayCallWithZeroLengthArrayArgument` inspection violation.
Description:
>Reports any call to toArray() on an object of type or subtype java.util.Collection with a zero-length array argument. When passing in an array of too small size, the toArray() method has to construct a new array of the right size using reflection. This has significantly worse performance than passing in an array of at least the size of the collection itself.
Fixes `ArraysAsListWithZeroOrOneArgument` inspection violation.
Description:
>Reports any calls to Arrays.asList() with zero arguments or only one argument. Such calls could be replaced with either a call to Collections.singletonList() or Collections.emptyList() which will save some memory.
Fixes `FloatingPointEquality` inspection violation.
Description:
>Reports floating-point values being compared with an == or != operator. Floating point values are inherently inaccurate, and comparing them for exact equality is almost never the desired semantics. This inspection ignores comparisons with zero and infinity literals.
Fixes `QuestionableName` inspection violations.
Description:
>Reports on any variables, methods, or classes with questionable names. This inspection is best used to report common metasyntactic variables which may be used as names by lazy or confused developers.
Use the list below to specify names which should be reported
Fixes `StandardVariableNames` inspection violations.
Description:
>Reports on any variables with 'standard' names which are of unexpected types. Such names may be confusing. Standard names and types are as follows:
* i, j, k, m, n - int
* f - float
* d - double
* b - byte
* c, ch - char
* l - long
* s, str - String
Fixes `UseOfPropertiesAsHashtable` inspection violations.
Description:
>Reports any calls to the java.util.Hashtable methods put(), putAll() or get() on a java.util.Properties object. For reasons lost to history, Properties inherits from Hashtable, but use of those methods is discouraged to prevent corruption of properties values with non-String data.
Fixes ClassNewInstance inspection violation.
Description:
Reports any calls to java.lang.Class.newInstance(). The newInstance method propagates any exception thrown by the no-arg constructor, including checked exceptions. Use of this method effectively bypasses the compile-time exception checking that would otherwise be performed by the compiler. Replacing such a method call with a call to the java.lang.reflect.Constructor.newInstance() method avoids this problem by wrapping any exception thrown by the constructor in a java.lang.reflect.InvocationTargetException.
Fixes SubtractionInCompareTo inspection violations.
Description:
>Reports subtraction in compareTo() methods and methods implementing java.util.Comparator.compare(). While it is a common idiom to use the results of integer subtraction as the result of a compareTo() method, this construct may cause subtle and difficult bugs in cases of integer overflow.
Fixes SuspiciousMethodCalls inspection violation.
Description:
>This inspection reports method calls to parameterized collections, where actual argument type does not correspond to the collection's elements type. For example if you have the following code:
```
List<Integer> list = getListOfElements();
list.remove("");
```
the call to `remove()` will be highlighted.
Fixes UnusedAssignment inspection violations.
Description:
>This inspection points out the cases where a variable value is never used after its assignment, i.e.:
- the variable never gets read after assignment OR
- the value is always overwritten with another assignment before the next variable read OR
- the variable initializer is redundant (for one of the above two reasons) OR
- the variable is never used.
Fixes AssignmentToCollectionFieldFromParameter violations.
Description:
>Reports any attempt to assign an array or Collection field from a method parameter. Since the array or Collection may have its contents modified by the calling method, this construct may result in an object having its state modified unexpectedly. While occasionally useful for performance reasons, this construct is inherently bug-prone.
Andrei Selkin
Baratali Izmailov
Michal Kordas
Aleksandr Ivanov
Ruslan Diachenko