mirror of
https://gitflic.ru/project/openide/openide.git
synced 2026-03-22 06:50:54 +07:00
371 lines
13 KiB
Plaintext
371 lines
13 KiB
Plaintext
|
|
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(*) |