| |
| Announcing version 1.0 of the InspectionGadgets plugin, available via the PluginManager |
| or at http://www.intellij.org/twiki/bin/view/Main/InspectionGadgets. |
| |
| Changes in version 1.0 |
| |
| New inspections: |
| |
| * Use of '$' in identifier |
| * Infinite Recursion |
| * Auto-Boxing |
| * Auto-Unboxing |
| * Unnecessary boxing |
| * Unnecessary unboxing |
| * Class without no-arg constructor |
| * Unnecessary 'final' for method parameter |
| * Unnecessarily qualified static method call |
| * Unqualified static method call |
| * setUp() with incorrect signature |
| * tearDown() with incorrect signature |
| * setUp() doesn't call super.setUp() |
| * tearDown() doesn't call super.tearDown() |
| * Test method with incorrect signature |
| * 'assert' statement |
| * Use of 'enum' as identifier |
| |
| plus huge numbers of bugfixes. |
| |
| Special thanks go to Bas Lejsdekkers and Keith Lea for their help and ideas on this release. |
| |
| With the 1.0 release, development on InspectionGadgets will be going into "bugfixes-only" |
| mode for the next several months. Thanks to everyone for your ideas, code, and |
| criticism as I developed InspectionGadgets. It's thanks to your interest and support |
| that InspectionGadgets has become the most full-featured and powerful Java static analysis |
| tool available today, and the most-downloaded IDEA plugin. I hope I've helped you kill a |
| lot of bugs. |
| |
| |
| |
| |
| * Abstraction issues |
| * Cast to a concrete class |
| * Class references one of its subclasses |
| * Collection declared by class, not interface |
| * Concrete class for instance variable |
| * Concrete class for local variable |
| * Concrete class for method parameter |
| * Concrete class for method return |
| * Concrete class for static variable |
| * 'instanceof' a concrete class |
| * "Magic number" |
| * 'switch' statement |
| |
| * Class metrics |
| * Class too deep in inheritance tree |
| * Class with too many constructors |
| * Class with too many fields |
| * Class with too many methods |
| * Inner class too deeply nested |
| * Overly complex class |
| * Overly coupled class |
| |
| * Class structure |
| * Abstract class extends concrete class |
| * Abstract class without abstract methods |
| * Abstract method overrides abstract method |
| * Abstract method overrides concrete method |
| * Class may be interface |
| * Class without constructor |
| * Class without no-arg constructor |
| * Class without package statement |
| * Constant declared in abstract class |
| * Constant declared in interface |
| * constructor not 'protected' in 'abstract' class(*) |
| * 'final' method in 'final' class(*) |
| * Inner class of interface |
| * No-op method in abstract class |
| * 'private' method declared 'final'(*) |
| * 'protected' member in 'final' class(*) |
| * 'public' constructor in non-'public' class(*) |
| * Static inheritance |
| * 'static' method declared 'final'(*) |
| * 'static', non-'final' field |
| * Utility class |
| * Utility class with public constructor |
| * Utility class without private constructor |
| |
| * Cloning issues |
| * clone() doesn't call super.clone() |
| * clone() doesn't declare CloneNotSupportedException |
| * clone() instantiates objects with constructor |
| * Cloneable class without 'clone()' |
| |
| * Code maturity issues |
| * Call to printStackTrace() |
| * Call to Thread.dumpStack() |
| * Class without toString() |
| * Use of obsolete collection type |
| * Use of System.out or System.err |
| |
| * Code style issues |
| * C-style array declaration(*) |
| * Constant on left side of comparison(*) |
| * Constant on right side of comparison(*) |
| * expression.equals("literal") rather than "literal".equals(expression)(*) |
| * Missorted modifers(*) |
| * Multiple variables in one declaration(*) |
| * Return of 'this' |
| * Unnecessarily qualified static method call(*) |
| * Unqualified static method call(*) |
| * Variables of different types in one declaration(*) |
| |
| * Encapsulation issues |
| * Assignment to Collection or array field from parameter |
| * Package-visible field |
| * Package-visible inner class |
| * Protected field |
| * Protected inner class |
| * Public field |
| * Public inner class |
| * Return of Collection or array field |
| |
| * Error handling |
| * 'catch' generic class |
| * Checked exception class |
| * Empty 'catch' block |
| * Empty 'finally' block |
| * Empty 'try' block |
| * Error not rethrown |
| * 'instanceof' on 'catch' parameter |
| * Nested 'try' statement |
| * Overly broad 'catch' block |
| * 'return' inside 'finally' block |
| * ThreadDeath not rethrown |
| * 'throw' generic class |
| * 'throw' inside 'catch' block which ignores the caught exception |
| * 'throw' inside 'finally' block |
| * Unchecked exception class |
| |
| * Finalization issues |
| * finalize() called explicitly |
| * finalize() doesn't call super.finalize() |
| * finalize() not declared 'protected'(*) |
| * Use of finalize() |
| |
| * Imports |
| * * import |
| * Import from same package |
| * java.lang import |
| * Redundant import |
| * Single class import |
| * Unused import |
| |
| * Initialization issues |
| * Abstract method call in constructor |
| * Instance variable may not be initialized |
| * Overridable method call in constructor |
| * Static variable may not be initialized |
| |
| * Internationalization issues |
| * Call to Date.toString() |
| * Call to Numeric .toString() |
| * Call to String.compareTo() |
| * Call to String.equals() |
| * Call to String.equalsIgnoreCase() |
| * Call to Time.toString() |
| * Character comparison |
| * Hardcoded string literal |
| * "Magic character" |
| * String concatenation |
| * Use of StringTokenizer |
| |
| * JUnit issues |
| * JUnit TestCase with non-trivial constructors |
| * Missing message on JUnit assertion |
| * setUp() doesn't call super.setUp() |
| * setUp() with incorrect signature |
| * 'setup()' instead of 'setUp()'(*) |
| * 'suite()' method not declared 'static' |
| * tearDown() doesn't call super.tearDown() |
| * tearDown() with incorrect signature |
| * 'teardown()' instead of 'tearDown()'(*) |
| * Test method with incorrect signature |
| |
| * Method metrics |
| * Method with more than three negations |
| * Method with multiple loops |
| * Method with multiple return points. |
| * Method with too many parameters |
| * Overly complex method |
| * Overly coupled method |
| * Overly long method |
| * Overly nested method |
| |
| * Naming conventions |
| * Class name prefixed with package name(*) |
| * Class naming convention(*) |
| * Confusing 'main()' method(*) |
| * Constant naming convention(*) |
| * Exception class name doesn't end with Exception(*) |
| * Instance method naming convention(*) |
| * Instance variable naming convention(*) |
| * Interface naming convention(*) |
| * Local Variable naming convention(*) |
| * Method name same as class name(*) |
| * Method name same as parent class name(*) |
| * Method parameter naming convention(*) |
| * Non-exception class name ends with 'Exception'(*) |
| * Standard variable names(*) |
| * Static method naming convention(*) |
| * Static variable naming convention(*) |
| * Use of '$' in identifier(*) |
| |
| * Performance issues |
| * Boolean constructor call(*) |
| * Calls to System.gc() or Runtime.gc() |
| * Collection without initial capacity |
| * Field may be 'static'(*) |
| * Field repeatedly accessed in method |
| * Manual array copy(*) |
| * Multiply or divide by power of two(*) |
| * Object allocation in loop |
| * Redundant String constructor call(*) |
| * Redundant String.toString()(*) |
| * Single character .startsWith() or .endsWith() |
| * Single character string concatenation(*) |
| * Static collection |
| * String concatenation in loop |
| * StringBuffer without initial capacity |
| * StringBuffer.toString() in concatenation(*) |
| * Tail recursion |
| * Unnecessary temporary object in conversion from String(*) |
| * Unnecessary temporary object in conversion to String(*) |
| * Use of java.lang.reflect |
| * Zero-length array allocation |
| |
| * Portability issues |
| * 'assert' statement |
| * Auto-boxing(*) |
| * Auto-unboxing(*) |
| * Call to Runtime.exec() |
| * Call to System.exit() |
| * Call to System.getenv() |
| * Hardcoded file separator |
| * Hardcoded line separator |
| * Native method |
| * Use of 'assert' as identifier(*) |
| * Use of 'enum' as identifier(*) |
| |
| * Potentially confusing code constructs |
| * Assignment to for-loop parameter |
| * Assignment to method parameter |
| * 'break' statement |
| * 'break' statement with label |
| * Chained equality comparisons |
| * Chained method calls |
| * Conditional expression (?:) |
| * Confusing else branch |
| * Confusing floating-point literal(*) |
| * 'continue' statement |
| * 'continue' statement with label |
| * If statement with negated condition |
| * Implicit call to super()(*) |
| * Implicit numeric conversions(*) |
| * Local variable used and declared in different 'switch' branches |
| * Long literal ending with 'l' instead of 'L'(*) |
| * Method names differing only by case |
| * Nested 'switch' statement |
| * Nested assignment |
| * Nested conditional expression |
| * Nested method calls |
| * Numeric cast that loses precision |
| * Overloaded methods with same number of parameters |
| * Overly complex arithmetic expression |
| * Overly complex boolean expression |
| * Switch statement with too few branches |
| * Switch statement with too many branches |
| * Value of ++ or -- used |
| |
| * Probable bugs |
| * Assignment to 'null' |
| * Assignment used as condition |
| * 'compareto()' instead of 'compareTo()'(*) |
| * Comparison of short and char values |
| * Covariant compareTo() |
| * Covariant equals() |
| * 'default' not last case in 'switch' |
| * equals() between objects of inconvertible types |
| * Fallthrough in 'switch' statement |
| * Floating point equality comparison |
| * For loop where update or condition doesn't use loop variable |
| * For loop with missing components |
| * 'hashcode()' instead of 'hashCode()'(*) |
| * Infinite loop statement |
| * Infinite recursion |
| * Loop statement that doesn't loop |
| * Non-final field referenced in 'compareTo()' |
| * Non-final field referenced in 'equals()' |
| * Non-final field referenced in 'hashCode()' |
| * Object comparison using ==, instead of '.equals()'(*) |
| * Octal and decimal integers in same array |
| * Result of InputStream.read() ignored |
| * Return of 'null' |
| * Statement with empty body |
| * String comparison using ==, instead of '.equals()'(*) |
| * Subtraction in compareTo() |
| * 'switch' statement without 'default' branch |
| * Text label in 'switch' statement |
| |
| * Security issues |
| * Cloneable class in secure context |
| * Deserializable class in secure context |
| * Non-static inner class in secure context |
| * Serializable class in secure context |
| |
| * Serialization issues |
| * Instance variable may not be initialized by readObject |
| * Non-serializable class with 'readObject()' or 'writeObject()' |
| * Non-serializable class with serialVersionUID |
| * 'readObject()' or 'writeObject()' not declared 'private'(*) |
| * 'readResolve()' or 'writeReplace()' not declared 'protected'(*) |
| * Serializable class with unconstructable ancestor |
| * Serializable class without 'readObject()' and 'writeObject()' |
| * Serializable class without serialVersionUID |
| * 'serialVersionUID' field not declared 'static final'(*) |
| * Transient field in non-serializable class(*) |
| |
| * Threading issues |
| * Busy wait |
| * Call to notify() instead of notifyAll()(*) |
| * Call to Thread.run()(*) |
| * Double-checked locking |
| * Empty 'synchronized' statement |
| * Field accessed in both synchronized and unsynchronized contexts |
| * Nested 'synchronized' statement |
| * Non-private field accessed in synchronized context |
| * Non-synchronized method overrides synchronized method |
| * Synchronization on 'this' |
| * Synchronization on a non-final field |
| * 'synchronized' method |
| * 'wait()' not in loop |
| |
| * Verbose or redundant code constructs |
| * Assignment replacable with operator assignment(*) |
| * Class explicitly extends java.lang.Object |
| * 'for' loop may be replaced by 'while' loop(*) |
| * Pointless arithmetic expression(*) |
| * Redundant boolean comparison(*) |
| * Redundant field initialization(*) |
| * Unnecessary 'final' for method parameter(*) |
| * Unnecessary 'if' statement(*) |
| * Unnecessary 'return' statement(*) |
| * Unnecessary 'super()' statement(*) |
| * Unnecessary 'this' qualifier(*) |
| * Unnecessary boxing(*) |
| * Unnecessary code block(*) |
| * Unnecessary fully qualified name(*) |
| * Unnecessary interface modifier(*) |
| * Unnecessary parentheses(*) |
| * Unnecessary semicolon(*) |
| * Unnecessary unboxing(*) |
| * Unused label(*) |
| |
| * Visibility issues |
| * Field name hides field in superclass(*) |
| * Inner class field hides outer class field(*) |
| * Local variable hides member variable(*) |
| * Method overloads method of superclass(*) |
| * Method overrides private method of superclass(*) |
| * Method overrides static method of superclass(*) |
| * Parameter hides member variable(*) |
