Readability & Refactor rules

Ensure that destructuring is used in function parameters where applicable. This improves readability by clearly showing accessed properties and default values.

Use object and array destructuring to access properties from objects (like `props`, `this`, context in `setup`) or elements from arrays, especially when accessing multiple items.

Validate and return early to reduce nesting and improve readability.

When a value comes from a finite set, model it as an enum constant instead of string/int literals.

Replace string literals that represent finite sets with enums (optionally flagged) or constants.

Ensure that simple methods and properties use expression-bodied syntax to improve code conciseness and readability.

Validate and return early to avoid deep nesting.

Use safe calls (?.), the Elvis operator (?:), let/run/also for scoped handling, and early returns for invalid input.

Document public items with /// and modules/crates with //!; include minimal runnable examples that pass doctests where applicable.

Prefer comprehensions over map/filter chains and avoid double-sorting or sorting inside loops.

Check if the code imports individual classes or functions instead of the entire module. Directly importing specific classes or functions can clutter the titlespace and increase naming conflicts. Recommend importing the module and referencing items explicitly.

Replace numeric/string literals with named constants to document meaning.

Prefer redirect() and notFound() over manual 302/404 handling and custom components in App Router.

Ensure that arithmetic and logical operators have spaces around them for better readability (e.g., `x + y` instead of `x+y`).

Prefer precise types (long, BigDecimal, LocalDate) over Number/Object when the domain is known.

Prefer Struct (or value objects) over OpenStruct for performance and type clarity.

Check for cases of string concatenation using +. Template literals improve readability and are less error-prone.

Check if function signatures include type annotations. Type hints improve readability and help catch type-related errors early. Recommend adding type annotations where missing.

Ensure that functions in public APIs include type annotations. Type annotations improve code clarity and help catch type-related errors early. Recommend adding them where missing.

Add scalar/union/nullable type hints and return types to functions, methods, and properties; prefer interfaces over mixed.

Detect multiple statements on the same line, separated by semicolons. This reduces readability and debugging efficiency. Recommend placing each statement on its own line.