Static Analysis

When to run

• After generating or significantly modifying any class
• When the user asks for a review, audit, or correctness check
• Before marking a backlog task as done

Focus especially on mutation methods (put, remove, add, set, clear, rehash, resize), as they are the most common source of structural bugs.

Analysis checklist

Run every item below. Report only findings — skip items with no issues.

1. Critical — bugs, contract violations, broken invariants

Logic and contract violations

• Logic bugs (off-by-one, wrong condition, unreachable branch)
• Broken invariants (e.g. size consistency, structural integrity of internal data structures)
• UnsupportedOperationException thrown silently by an inherited method without being documented
• Abstract base class contract violations (e.g. entrySet() inconsistent with size(), get(), containsKey())
• Concurrent modification not handled correctly in synchronized implementations (missing lock, wrong lock type)
• Resize/rehash leaving entries in an inconsistent state

Structural invariants

• Class invariants not documented (preferably using formal contracts)
• Constructor does not establish all invariants
• Mutation methods break invariants
• Temporary invariant violations not restored before method exit

2. Major — performance, mutation safety, iterator correctness

Complexity

• Method expected to be O(1) accidentally iterates the whole structure
• Method inherited from an abstract base class causing hidden O(n) behaviour
• Resize or rehash logic breaking amortized complexity guarantees

Mutation consistency

• All internal structures not updated consistently after mutation
• size() inconsistent after add/remove operations
• remove() leaves stale references
• clear() does not fully reset the structure

Iterator correctness

• Iterator does not respect the contract of the implemented interface
• iterator.remove() incorrect or unsupported without documentation
• Missing ConcurrentModificationException where fail-fast behaviour is expected

Null safety

• Missing null check where the contract requires it
• null returned where the contract specifies a non-null return
• Nullable types used as parameter type or collection element where forbidden by standards

Behavioural consistency

• Mutation through views or entries not maintaining structural invariants
• Configuration change not atomic in synchronized implementations
• Snapshot cost not documented in Javadoc for copy-based operations

3. Minor — style, documentation, guideline compliance

File structure

• File header missing or malformed
• Version in file header does not match the build file

Imports / dependencies

• Wildcard or unused imports present
• Imports not sorted according to project conventions

Code organisation

• Declaration order violated
• Section separators missing or malformed

Documentation

• Documentation missing on a public class or public method
• Parameters, return values, or exceptions not documented where applicable
• Overridden method with different semantics has no documentation

Language

• Any identifier, comment, documentation, exception message, or log message not in English

Output format

Report findings grouped by severity:

1. Critical — with file, line, and explanation
2. Major — with file, line, and explanation
3. Minor — with file, line, and explanation

If no issues are found in a severity level, skip it entirely.