@critiq/rules 0.3.0 → 0.4.0

package/rules/java/java.correctness.ignored-inputstream-read.rule.yaml

@@ -0,0 +1,45 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.ignored-inputstream-read
+  title: Return value of InputStream.read() ignored
+  summary: Calling `read()` on an InputStream without using the return value discards data.
+  rationale: "InputStream.read() returns the number of bytes read. Ignoring this value can lead to data loss or incorrect assumptions about how many bytes were consumed."
+  detection:
+    kind: pattern
+  aliases:
+    - JAVA-E0183
+  tags:
+    - correctness
+    - java
+    - resource
+    - rules-catalog
+  stability: stable
+  appliesTo: block
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.ignored-inputstream-read
+    bind: issue
+emit:
+  finding:
+    category: correctness.resource
+    severity: medium
+    confidence: 0.85
+    tags:
+      - correctness
+      - java
+  message:
+    title: InputStream.read() return value ignored
+    summary: The return value of `read()` is not captured or checked. The actual number of bytes read may differ from the buffer size.
+  remediation:
+    summary: Capture and check the return value of `read()`, for example `int n = is.read(buf);`

package/rules/java/java.correctness.ignored-inputstream-skip.rule.yaml

@@ -0,0 +1,45 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.ignored-inputstream-skip
+  title: Return value of InputStream.skip ignored
+  summary: Calling `skip()` on an InputStream without using the return value discards data.
+  rationale: "InputStream.skip() returns the actual number of bytes skipped, which may be less than requested. Ignoring this value can lead to incorrect stream positioning."
+  detection:
+    kind: pattern
+  aliases:
+    - JAVA-E0184
+  tags:
+    - correctness
+    - java
+    - resource
+    - rules-catalog
+  stability: stable
+  appliesTo: block
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.ignored-inputstream-skip
+    bind: issue
+emit:
+  finding:
+    category: correctness.resource
+    severity: medium
+    confidence: 0.85
+    tags:
+      - correctness
+      - java
+  message:
+    title: InputStream.skip() return value ignored
+    summary: The return value of `skip()` is not captured or checked. Fewer bytes may have been skipped than requested.
+  remediation:
+    summary: Capture and check the return value of `skip()`, for example `long n = is.skip(100);`

package/rules/java/java.correctness.illegal-monitor-state-caught.rule.yaml

@@ -0,0 +1,45 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.illegal-monitor-state-caught
+  title: IllegalMonitorStateException should not be handled
+  summary: IllegalMonitorStateException indicates a programming error; handling it masks the bug.
+  rationale: This exception signals incorrect `wait()`/`notify()` usage. Fix the synchronization logic instead of catching it.
+  detection:
+    kind: pattern
+  aliases:
+    - JAVA-E0040
+  tags:
+    - correctness
+    - java
+    - concurrency
+    - rules-catalog
+  stability: stable
+  appliesTo: block
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.illegal-monitor-state-caught
+    bind: issue
+emit:
+  finding:
+    category: correctness.concurrency
+    severity: high
+    confidence: 0.90
+    tags:
+      - correctness
+      - java
+  message:
+    title: Catching IllegalMonitorStateException masks synchronization bug
+    summary: "IllegalMonitorStateException should not be caught. Fix the synchronization logic instead."
+  remediation:
+    summary: Fix the synchronization logic that causes IllegalMonitorStateException rather than catching it.

package/rules/java/java.correctness.impossible-toarray-downcast.rule.yaml

@@ -0,0 +1,45 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.impossible-toarray-downcast
+  title: Impossible downcast of toArray() result
+  summary: Casting the result of no-arg toArray() to a specific array type will throw ClassCastException.
+  rationale: Collection.toArray() returns Object[] and cannot be cast to a more specific array type. Use toArray(T[]) instead.
+  detection:
+    kind: pattern
+  aliases:
+    - JAVA-E0386
+  tags:
+    - correctness
+    - java
+    - collections
+    - rules-catalog
+  stability: experimental
+  appliesTo: block
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.impossible-toarray-downcast
+    bind: issue
+emit:
+  finding:
+    category: correctness.type-safety
+    severity: critical
+    confidence: 0.95
+    tags:
+      - correctness
+      - java
+  message:
+    title: Impossible downcast of toArray() result
+    summary: "`${captures.issue.text}` casts the no-arg toArray() to a specific array type, which will throw ClassCastException at runtime."
+  remediation:
+    summary: Use `toArray(new Foo[0])` or `toArray(new Foo[list.size()])` instead of casting the no-arg result.

package/rules/java/java.correctness.incorrect-main-signature.rule.yaml

@@ -0,0 +1,42 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.incorrect-main-signature
+  title: Incorrect main method signature detected
+  summary: A method named main does not match the required public static void main(String[]) or String... signature, so it will not be usable as a program entry point.
+  rationale: The JVM requires main methods to have the exact signature public static void main(String[] args) or public static void main(String... args). Methods named main with wrong return types, missing static, or incorrect parameter types will not be recognized as entry points.
+  tags:
+    - correctness
+    - java
+    - rules-catalog
+  stability: stable
+  appliesTo: block
+  aliases:
+    - JAVA-E1105
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.incorrect-main-signature
+    bind: issue
+emit:
+  finding:
+    category: correctness.general
+    severity: high
+    confidence: 0.95
+    tags:
+      - correctness
+      - java
+  message:
+    title: Incorrect main method signature in `${captures.issue.text}`
+    summary: A method named main does not match the required public static void main(String[]) or String... signature and will not be usable as a program entry point.
+  remediation:
+    summary: Change the method signature to `public static void main(String[] args)` or `public static void main(String... args)`.

package/rules/java/java.correctness.indexof-reversed-arguments.rule.yaml

@@ -0,0 +1,42 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.indexof-reversed-arguments
+  title: "Avoid reversed arguments to `String.indexOf()`"
+  summary: "Calling `indexOf()` with an integer as the first argument and a string as the second likely has the arguments reversed."
+  rationale: "`String.indexOf(int ch, int fromIndex)` takes a character code as the first argument and a starting position as the second. Passing `indexOf(0, \"str\")` compiles because `0` is a valid char code and `\"str\"` is treated as `fromIndex`. The developer likely meant `indexOf(\"str\")` or `indexOf(\"str\", 0)`."
+  aliases:
+    - JAVA-E1089
+  tags:
+    - correctness
+    - java
+    - rules-catalog
+  stability: experimental
+  appliesTo: block
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.indexof-reversed-arguments
+    bind: issue
+emit:
+  finding:
+    category: correctness.api-misuse
+    severity: high
+    confidence: 0.90
+    tags:
+      - correctness
+      - java
+  message:
+    title: "Arguments to `indexOf()` appear to be reversed in `${captures.issue.text}`"
+    summary: "Calling `indexOf(int, String)` suggests the arguments are reversed. The first argument should be the character to find, the second the start position."
+  remediation:
+    summary: "Use `indexOf(\"str\")` to search for a substring, or `indexOf(\"str\", fromIndex)` to specify a start position. Use a character literal for single-character searches."

package/rules/java/java.correctness.instant-unsupported-temporal-unit.rule.yaml

@@ -0,0 +1,42 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.instant-unsupported-temporal-unit
+  title: "Instant should not be passed unsupported temporal unit types"
+  summary: "`Instant.plus()`, `Instant.minus()`, and `Instant.until()` throw `UnsupportedTemporalTypeException` when called with date-based units such as WEEKS, MONTHS, or YEARS."
+  rationale: "`Instant` represents an instantaneous point on the time-line and does not support date-based fields. Using `ChronoUnit.WEEKS`, `MONTHS`, `YEARS`, `DECADES`, `CENTURIES`, `MILLENNIA`, `ERAS`, or `FOREVER` with `Instant.plus()`, `minus()`, or `until()` throws `UnsupportedTemporalTypeException`. Use `ChronoUnit.DAYS`, `HOURS`, `MINUTES`, `SECONDS`, `NANOS`, etc. instead."
+  aliases:
+    - JAVA-E1094
+  tags:
+    - correctness
+    - java
+    - rules-catalog
+  stability: experimental
+  appliesTo: block
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.instant-unsupported-temporal-unit
+    bind: issue
+emit:
+  finding:
+    category: correctness.exceptions
+    severity: high
+    confidence: 0.85
+    tags:
+      - correctness
+      - java
+  message:
+    title: "Date-based ChronoUnit used with Instant method in `${captures.issue.text}`"
+    summary: "Instant does not support date-based temporal units (WEEKS, MONTHS, YEARS, etc.). Use time-based units like DAYS, HOURS, MINUTES, or SECONDS."
+  remediation:
+    summary: "Replace date-based ChronoUnit (WEEKS, MONTHS, YEARS) with time-based units (DAYS, HOURS, MINUTES, SECONDS, NANOS)."

package/rules/java/java.correctness.invalid-regex-literal.rule.yaml

@@ -0,0 +1,45 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.invalid-regex-literal
+  title: Invalid regex syntax must not be used
+  summary: The regex pattern string contains invalid syntax (e.g. unmatched brackets, reversed character range, or invalid escape).
+  rationale: Invalid regex patterns will throw PatternSyntaxException at runtime.
+  detection:
+    kind: pattern
+  aliases:
+    - JAVA-E0394
+  tags:
+    - correctness
+    - java
+    - regex
+    - rules-catalog
+  stability: experimental
+  appliesTo: block
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.invalid-regex-literal
+    bind: issue
+emit:
+  finding:
+    category: correctness.input-validation
+    severity: critical
+    confidence: 0.85
+    tags:
+      - correctness
+      - java
+  message:
+    title: Invalid regex syntax in `${captures.issue.text}`
+    summary: "The regex pattern contains invalid syntax (unmatched brackets, reversed range, or invalid escape) that will throw PatternSyntaxException."
+  remediation:
+    summary: Fix the regex pattern — ensure brackets are balanced, character ranges are ascending (`[a-z]` not `[z-a]`), and escape sequences are valid.

package/rules/java/java.correctness.invalid-serial-version-uid.rule.yaml

@@ -0,0 +1,42 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.invalid-serial-version-uid
+  title: serialVersionUID must be static final long
+  summary: The serialVersionUID field must be declared as static final long to serve as a valid serialization identifier.
+  rationale: Java's serialization mechanism requires serialVersionUID to be a static final long field. If it is declared with a different type (e.g., int), missing static or final modifiers, the serialization runtime will not recognize it as the version identifier, potentially leading to InvalidClassException during deserialization.
+  tags:
+    - correctness
+    - java
+    - rules-catalog
+  stability: experimental
+  appliesTo: block
+  aliases:
+    - JAVA-E1042
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.invalid-serial-version-uid
+    bind: issue
+emit:
+  finding:
+    category: correctness.serialization
+    severity: high
+    confidence: 0.95
+    tags:
+      - correctness
+      - java
+  message:
+    title: Invalid serialVersionUID declaration
+    summary: "`${captures.issue.text}` is not a valid serialVersionUID; it must be declared as `static final long`."
+  remediation:
+    summary: Change the field to `static final long serialVersionUID = <value>L;`.

package/rules/java/java.correctness.invalid-time-constants.rule.yaml

@@ -0,0 +1,42 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.invalid-time-constants
+  title: Invalid values for java.time constants will always throw a DateTimeException
+  summary: Calls to java.time factory methods with literal arguments outside valid ranges (month > 12, day > 31, hour >= 24, minute/seconds >= 60) will always throw DateTimeException at runtime.
+  rationale: The java.time API throws DateTimeException for out-of-range values. Using literal constants that are out of range is always a bug and should be caught at development time.
+  tags:
+    - correctness
+    - java
+    - rules-catalog
+  stability: stable
+  appliesTo: block
+  aliases:
+    - JAVA-E1099
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.invalid-time-constants
+    bind: issue
+emit:
+  finding:
+    category: correctness.exceptions
+    severity: high
+    confidence: 0.75
+    tags:
+      - correctness
+      - java
+  message:
+    title: Invalid time constant value in `${captures.issue.text}`
+    summary: A java.time factory method is called with a literal value that is outside the valid range and will always throw a DateTimeException at runtime.
+  remediation:
+    summary: Replace the out-of-range value with a valid constant within the documented range for the factory method.

package/rules/java/java.correctness.invalidated-iterator.rule.yaml

@@ -0,0 +1,42 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.invalidated-iterator
+  title: Do not modify collections while iterating
+  summary: Modifying a collection with `add()`, `remove()`, or `clear()` inside a for-each loop will throw a ConcurrentModificationException.
+  rationale: The iterator obtained by a for-each loop does not expect structural modifications to the underlying collection. Calling add/remove/clear invalidates the iterator and throws ConcurrentModificationException at runtime.
+  aliases:
+    - JAVA-E1085
+  tags:
+    - correctness
+    - java
+    - rules-catalog
+  stability: experimental
+  appliesTo: block
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.invalidated-iterator
+    bind: issue
+emit:
+  finding:
+    category: correctness.collections
+    severity: high
+    confidence: 0.85
+    tags:
+      - correctness
+      - java
+  message:
+    title: Iterator invalidated by collection modification in `${captures.issue.text}`
+    summary: "A collection is structurally modified inside a for-each loop, which will throw a ConcurrentModificationException."
+  remediation:
+    summary: Use an explicit Iterator with `iterator.remove()`, collect items for later removal, or use `removeIf()` for conditional removal during iteration.

package/rules/java/java.correctness.iterable-iterator-returns-this.rule.yaml

@@ -0,0 +1,44 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.iterable-iterator-returns-this
+  title: Iterable must not return this from iterator()
+  summary: A class implementing both Iterable and Iterator that returns this from iterator() cannot support multiple concurrent iterations and violates the Iterator contract.
+  rationale: Returning this from iterator() means the collection is its own iterator, which prevents multiple iterations and can lead to ConcurrentModificationException or incorrect iteration state when nested.
+  detection:
+    kind: pattern
+  aliases:
+    - JAVA-E1015
+  tags:
+    - correctness
+    - java
+    - rules-catalog
+  stability: experimental
+  appliesTo: block
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.iterable-iterator-returns-this
+    bind: issue
+emit:
+  finding:
+    category: correctness.api-usage
+    severity: high
+    confidence: 0.85
+    tags:
+      - correctness
+      - java
+  message:
+    title: Iterable.iterator() returns this
+    summary: The iterator() method in a class implementing both Iterable and Iterator returns this. This prevents multiple concurrent iterations and violates expected Iterator behavior.
+  remediation:
+    summary: Create a separate Iterator class instead of having the collection implement Iterator itself. Return a new iterator instance from iterator().

package/rules/java/java.correctness.iterable-path-type.rule.yaml

@@ -0,0 +1,42 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.iterable-path-type
+  title: "Iterable<Path> is errorprone and should be replaced with Collection<Path>"
+  summary: "`Path` implements `Iterable<Path>`, so `Iterable<Path>` creates confusing APIs. Use `Collection<Path>` instead for clarity."
+  rationale: "`java.nio.file.Path` extends `Iterable<Path>`, which means code treating a single `Path` as an `Iterable<Path>` compiles but produces surprising behavior (iterating over a single path's name elements instead of multiple paths). Using `Iterable<Path>` in method signatures is error-prone. Use `Collection<Path>` or `List<Path>` instead."
+  aliases:
+    - JAVA-E1096
+  tags:
+    - correctness
+    - java
+    - rules-catalog
+  stability: experimental
+  appliesTo: block
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.iterable-path-type
+    bind: issue
+emit:
+  finding:
+    category: correctness.api-design
+    severity: high
+    confidence: 0.85
+    tags:
+      - correctness
+      - java
+  message:
+    title: "Iterable<Path> is error-prone in `${captures.issue.text}`"
+    summary: "Since Path itself is Iterable<Path>, using Iterable<Path> as a parameter type can cause confusion. Use Collection<Path> or List<Path> instead."
+  remediation:
+    summary: "Replace `Iterable<Path>` with `Collection<Path>` or `List<Path>` to avoid ambiguity with `Path`'s own iteration."

package/rules/java/java.correctness.jump-in-finally.rule.yaml

@@ -0,0 +1,44 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.jump-in-finally
+  title: Jump statements must not be used within finally blocks
+  summary: Using return, throw, or break in a finally block overrides any exception or return value from the try block.
+  rationale: Control flow statements (return, throw) in finally blocks suppress exceptions thrown in the corresponding try block and obscure the normal return path, leading to subtle bugs.
+  detection:
+    kind: pattern
+  aliases:
+    - JAVA-E1007
+  tags:
+    - correctness
+    - java
+    - rules-catalog
+  stability: experimental
+  appliesTo: block
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.jump-in-finally
+    bind: issue
+emit:
+  finding:
+    category: correctness.control-flow
+    severity: high
+    confidence: 0.85
+    tags:
+      - correctness
+      - java
+  message:
+    title: Jump statement in finally block
+    summary: "`${captures.issue.text}` is a jump statement inside a finally block and will override any return value or exception from the try block."
+  remediation:
+    summary: Remove return, throw, and break statements from finally blocks. Keep finally blocks limited to cleanup operations.

package/rules/java/java.correctness.loop-condition-never-true.rule.yaml

@@ -0,0 +1,42 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.loop-condition-never-true
+  title: Loop condition is never true
+  summary: A loop condition that evaluates to false at compile time means the loop body will never execute.
+  rationale: Using a literal false value (or equivalent) as a loop condition guarantees the loop body never executes, which indicates dead code. This is often a debugging leftover or a logic error.
+  tags:
+    - correctness
+    - java
+    - rules-catalog
+  stability: experimental
+  appliesTo: block
+  aliases:
+    - JAVA-E1045
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.loop-condition-never-true
+    bind: issue
+emit:
+  finding:
+    category: correctness.control-flow
+    severity: high
+    confidence: 0.95
+    tags:
+      - correctness
+      - java
+  message:
+    title: Loop condition is never true
+    summary: "`${captures.issue.text}` will never execute its body since the condition is always false."
+  remediation:
+    summary: Remove the dead loop or fix the condition to evaluate to true when iteration is needed.