@critiq/rules 0.2.0 → 0.4.0

package/rules/java/java.correctness.assert-self-comparison.rule.yaml

@@ -0,0 +1,46 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.assert-self-comparison
+  title: Objects should not be compared to themselves within assertions
+  summary: Assertions comparing a value to itself always pass and indicate a testing bug where a different expected value should be used.
+  rationale: Self-comparison in assertions (assertEquals(a, a), assertSame(a, a), assertTrue(a == a)) is a common copy-paste mistake. These assertions always pass and never validate actual behavior.
+  detection:
+    kind: pattern
+  aliases:
+    - JAVA-E1012
+  tags:
+    - correctness
+    - java
+    - rules-catalog
+    - testing
+  stability: experimental
+  appliesTo: block
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.assert-self-comparison
+    bind: issue
+emit:
+  finding:
+    category: correctness.logic
+    severity: high
+    confidence: 0.85
+    tags:
+      - correctness
+      - java
+      - testing
+  message:
+    title: Self-comparison in assertion
+    summary: "`${captures.issue.text}` compares an object to itself. This assertion always passes and does not test anything meaningful."
+  remediation:
+    summary: Replace the self-comparison with the actual expected value. If testing equality contract, check equals/hashCode explicitly.

package/rules/java/java.correctness.assertion-in-production.rule.yaml

@@ -0,0 +1,49 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.assertion-in-production
+  title: Assert statement in production code
+  summary: "The `assert` keyword in Java is disabled at runtime. Do not use it for argument validation or precondition checks in production code."
+  rationale: "Java assertions are disabled by default and throw `AssertionError` (not a typed exception) when enabled. They should not be used for input validation, precondition checks, or any logic that must execute. Use `IllegalArgumentException`, `Objects.requireNonNull`, or explicit condition checks instead."
+  detection:
+    kind: pattern
+  references:
+    - kind: cwe
+      id: CWE-617
+      title: Reachable Assertion
+  aliases:
+    - JAVA-S0336
+  tags:
+    - correctness
+    - java
+    - defensive-programming
+    - rules-catalog
+  stability: stable
+  appliesTo: block
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.assertion-in-production
+    bind: issue
+emit:
+  finding:
+    category: correctness.defensive-programming
+    severity: low
+    confidence: 0.92
+    tags:
+      - correctness
+      - java
+  message:
+    title: Replace assert with proper validation in `${captures.issue.text}`
+    summary: "`${captures.issue.text}` uses the Java `assert` keyword which is disabled by default. Use explicit validation such as `Objects.requireNonNull` or `IllegalArgumentException` instead."
+  remediation:
+    summary: "Replace `assert` with explicit validation: `if (!condition) throw new IllegalArgumentException(\"...\")` or use `Objects.requireNonNull(value)` for null checks."

package/rules/java/java.correctness.bad-short-circuit-null-check.rule.yaml

@@ -0,0 +1,45 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.bad-short-circuit-null-check
+  title: Bad short-circuiting null check
+  summary: Null check uses || instead of && causing a NullPointerException when the variable is null.
+  rationale: In `x != null || x.method()`, if x is null, the first condition is false, so x.method() executes and throws NPE. Use && for null-guarded access.
+  detection:
+    kind: pattern
+  aliases:
+    - JAVA-E1003
+  tags:
+    - correctness
+    - java
+    - defensive-programming
+    - rules-catalog
+  stability: experimental
+  appliesTo: block
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.bad-short-circuit-null-check
+    bind: issue
+emit:
+  finding:
+    category: correctness.logic
+    severity: high
+    confidence: 0.90
+    tags:
+      - correctness
+      - java
+  message:
+    title: Bad short-circuit null check
+    summary: Using `||` instead of `&&` after a null check causes a NullPointerException when the variable is null.
+  remediation:
+    summary: Change `x != null || x.method()` to `x != null && x.method()` so the method call is guarded by the null check.

package/rules/java/java.correctness.bitwise-or-never-equal.rule.yaml

@@ -0,0 +1,42 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.bitwise-or-never-equal
+  title: Bitwise OR expression will never equal the comparison constant
+  summary: A bitwise OR expression is compared with `==` to a constant but will never equal it.
+  rationale: When using `(expr | C) == D`, if `C` has bits that `D` doesn't have, the expression always evaluates to false because OR adds bits.
+  aliases:
+    - JAVA-E1073
+  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.bitwise-or-never-equal
+    bind: issue
+emit:
+  finding:
+    category: correctness.logic
+    severity: high
+    confidence: 0.95
+    tags:
+      - correctness
+      - java
+  message:
+    title: Bitwise OR expression never equals constant in `${captures.issue.text}`
+    summary: "A bitwise OR comparison will always evaluate to the same result."
+  remediation:
+    summary: Use `&` (bitwise AND) instead of `|` to test for specific bits, or use a valid constant for comparison.

package/rules/java/java.correctness.boxed-boolean-conditional.rule.yaml

@@ -0,0 +1,42 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.boxed-boolean-conditional
+  title: Boxed Boolean in conditional expressions
+  summary: Using a boxed Boolean directly in a conditional can throw NullPointerException if the value is null.
+  rationale: Auto-unboxing a null Boolean in if/while/ternary expressions throws NullPointerException at runtime.
+  tags:
+    - correctness
+    - java
+    - rules-catalog
+  stability: stable
+  appliesTo: block
+  aliases:
+    - JAVA-E1054
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.boxed-boolean-conditional
+    bind: issue
+emit:
+  finding:
+    category: correctness.general
+    severity: high
+    confidence: 0.80
+    tags:
+      - correctness
+      - java
+  message:
+    title: Boxed Boolean in conditional expression
+    summary: Unboxing a null Boolean will throw NullPointerException.
+  remediation:
+    summary: Use `Boolean.TRUE.equals(flag)` or `boolean` primitive type, or guard with a null check before the conditional.

package/rules/java/java.correctness.cacheloader-null-return.rule.yaml

@@ -0,0 +1,42 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.cacheloader-null-return
+  title: CacheLoader load method should not return null
+  summary: Returning null from a CacheLoader.load() method causes InvalidCacheLoadException at runtime. Guava caches do not support null values.
+  rationale: CacheLoader.load() must never return null. Guava caches treat null returns as failures and throw InvalidCacheLoadException. The method should either return a non-null value or throw an exception.
+  tags:
+    - correctness
+    - java
+    - rules-catalog
+  stability: stable
+  appliesTo: block
+  aliases:
+    - JAVA-E1104
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.cacheloader-null-return
+    bind: issue
+emit:
+  finding:
+    category: correctness.exceptions
+    severity: medium
+    confidence: 0.7
+    tags:
+      - correctness
+      - java
+  message:
+    title: CacheLoader.load() returns null which will throw InvalidCacheLoadException
+    summary: The load() method of a CacheLoader subclass returns null. Guava caches do not allow null values and will throw InvalidCacheLoadException.
+  remediation:
+    summary: Return a non-null value, use Optional, or throw an exception instead of returning null from CacheLoader.load().

package/rules/java/java.correctness.case-insensitive-regex-lacks-unicode.rule.yaml

@@ -0,0 +1,46 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.case-insensitive-regex-lacks-unicode
+  title: Case insensitive regex does not properly handle Unicode input
+  summary: CASE_INSENSITIVE or (?i) without UNICODE_CASE or (?u) does not handle Unicode-aware case folding.
+  rationale: Without UNICODE_CASE, case-insensitive matching only handles ASCII characters. Unicode characters (e.g., accented letters, non-Latin scripts) will not be matched case-insensitively, leading to text processing bugs in internationalized applications.
+  detection:
+    kind: pattern
+  aliases:
+    - JAVA-E1010
+  tags:
+    - correctness
+    - java
+    - rules-catalog
+    - i18n
+  stability: experimental
+  appliesTo: block
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.case-insensitive-regex-lacks-unicode
+    bind: issue
+emit:
+  finding:
+    category: correctness.api-usage
+    severity: high
+    confidence: 0.85
+    tags:
+      - correctness
+      - java
+      - i18n
+  message:
+    title: Case-insensitive regex pattern without Unicode support
+    summary: "`${captures.issue.text}` uses case-insensitive matching without Unicode support. Add UNICODE_CASE or (?u) for proper internationalization."
+  remediation:
+    summary: Add Pattern.UNICODE_CASE (or (?u) flag) alongside CASE_INSENSITIVE flag for proper Unicode-aware case-insensitive matching.

package/rules/java/java.correctness.catch-null-pointer.rule.yaml

@@ -5,6 +5,10 @@ metadata:
   title: Do not catch NullPointerException
   summary: NullPointerException indicates a programming error.
   rationale: Catching NPE masks bugs that should be fixed at the source.
+  detection:
+    kind: pattern
+  aliases:
+    - JAVA-E1070
   tags:
     - correctness
     - java
@@ -28,7 +32,7 @@ match:
 emit:
   finding:
     category: correctness.exceptions
-    severity: low
+    severity: critical
     confidence: 0.88
     tags:
       - correctness

package/rules/java/java.correctness.class-isinstance-on-class.rule.yaml

@@ -0,0 +1,42 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.class-isinstance-on-class
+  title: "Use `instanceof` instead of `Class.isInstance()`"
+  summary: "Calling `.class.isInstance(obj)` should be replaced with `obj instanceof Type` for clarity and type safety."
+  rationale: "`SomeClass.class.isInstance(obj)` is equivalent to `obj instanceof SomeClass`, but the `instanceof` operator is more readable, type-safe at compile time, and is the idiomatic Java pattern for runtime type checking."
+  aliases:
+    - JAVA-E1091
+  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.class-isinstance-on-class
+    bind: issue
+emit:
+  finding:
+    category: correctness.code-style
+    severity: high
+    confidence: 0.95
+    tags:
+      - correctness
+      - java
+  message:
+    title: "Use `instanceof` instead of `.class.isInstance()` in `${captures.issue.text}`"
+    summary: "`SomeClass.class.isInstance(obj)` should be replaced with `obj instanceof SomeClass` for readability and compile-time type safety."
+  remediation:
+    summary: "Replace `X.class.isInstance(obj)` with `obj instanceof X`."

package/rules/java/java.correctness.class-name-collision.rule.yaml

@@ -0,0 +1,45 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.class-name-collision
+  title: Class name collides with superclass simple name
+  summary: A class shares its simple name with a superclass referenced in the extends clause, causing ambiguity.
+  rationale: When a class name matches the simple name of its explicit superclass, it can lead to confusion and subtle bugs where the wrong type is referenced. The collision obscures the inheritance relationship and reduces code clarity.
+  detection:
+    kind: pattern
+  aliases:
+    - JAVA-E0169
+  tags:
+    - correctness
+    - java
+    - types
+    - rules-catalog
+  stability: experimental
+  appliesTo: block
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.class-name-collision
+    bind: issue
+emit:
+  finding:
+    category: correctness.types
+    severity: medium
+    confidence: 0.85
+    tags:
+      - correctness
+      - java
+  message:
+    title: Class name collides with superclass name
+    summary: "Class `${captures.issue.text}` has the same simple name as its explicit superclass."
+  remediation:
+    summary: Rename the class or the superclass reference to avoid the name collision.

package/rules/java/java.correctness.clone-without-super.rule.yaml

@@ -0,0 +1,45 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.clone-without-super
+  title: Clone method does not call super.clone()
+  summary: "`clone()` methods should call `super.clone()` to create the correct object."
+  rationale: "Without `super.clone()`, the cloned object may not be properly initialized. `super.clone()` copies the object's internal state."
+  detection:
+    kind: pattern
+  aliases:
+    - JAVA-E0048
+  tags:
+    - correctness
+    - java
+    - contract-violation
+    - rules-catalog
+  stability: stable
+  appliesTo: block
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.clone-without-super
+    bind: issue
+emit:
+  finding:
+    category: correctness.contract-violation
+    severity: high
+    confidence: 0.80
+    tags:
+      - correctness
+      - java
+  message:
+    title: clone() does not call super.clone()
+    summary: "`clone()` methods should call `super.clone()` to create the correct object."
+  remediation:
+    summary: "Add `super.clone()` call at the beginning of the `clone()` method."

package/rules/java/java.correctness.closeable-provides-injection.rule.yaml

@@ -0,0 +1,43 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.closeable-provides-injection
+  title: Closeable values should not be injected via @Provides annotated methods
+  summary: "@Provides/@Inject methods returning Closeable types can cause resource management problems."
+  rationale: DI frameworks may hold Closeable resources longer than intended, preventing proper cleanup. Scope the resource or use a factory that manages lifecycle.
+  aliases:
+    - JAVA-E1103
+  tags:
+    - correctness
+    - java
+    - framework
+    - rules-catalog
+  stability: experimental
+  appliesTo: block
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.closeable-provides-injection
+    bind: issue
+emit:
+  finding:
+    category: correctness.resource-management
+    severity: high
+    confidence: 0.85
+    tags:
+      - correctness
+      - java
+  message:
+    title: Closeable type returned from @Provides method
+    summary: "The method returns a Closeable type that may not be properly closed by the DI container."
+  remediation:
+    summary: Return a factory or wrapper that manages the Closeable lifecycle instead of exposing it directly from @Provides/@Inject.

package/rules/java/java.correctness.collection-adds-self.rule.yaml

@@ -0,0 +1,42 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.collection-adds-self
+  title: Collections should not be added to themselves
+  summary: A collection is being added to itself, which is likely a logic error.
+  rationale: Self-add operations on collections are almost always unintentional typos where the wrong variable was used.
+  aliases:
+    - JAVA-E1077
+  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.collection-adds-self
+    bind: issue
+emit:
+  finding:
+    category: correctness.logic
+    severity: high
+    confidence: 0.95
+    tags:
+      - correctness
+      - java
+  message:
+    title: Collection added to itself in `${captures.issue.text}`
+    summary: "A collection is being added to itself, which is likely a logic error."
+  remediation:
+    summary: Use a different collection reference for the add operation.

package/rules/java/java.correctness.collection-contains-self.rule.yaml

@@ -0,0 +1,42 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.collection-contains-self
+  title: Collections should not contain themselves
+  summary: A collection checks if it contains itself — likely a logic error.
+  rationale: Self-containment checks on collections are almost always unintentional typos where the wrong variable was used.
+  aliases:
+    - JAVA-E1076
+  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.collection-contains-self
+    bind: issue
+emit:
+  finding:
+    category: correctness.logic
+    severity: critical
+    confidence: 0.95
+    tags:
+      - correctness
+      - java
+  message:
+    title: Collection contains check on itself in `${captures.issue.text}`
+    summary: "A collection checks for containment of itself, which is likely a logic error."
+  remediation:
+    summary: Use a different collection reference for the containment check.

package/rules/java/java.correctness.collection-remove-type-mismatch.rule.yaml

@@ -0,0 +1,42 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.collection-remove-type-mismatch
+  title: Wrong argument type for Collection remove method
+  summary: Passing a numeric literal to Collection.remove() on a collection with a non-numeric generic type will silently fail to remove the intended element.
+  rationale: Although Collection.remove(Object) accepts any Object, passing an argument of the wrong type (e.g., an int to a List<String>) will never match an existing element. The remove call may succeed in removing a value that happens to match the object's equals/hashCode, but typically represents a bug.
+  tags:
+    - correctness
+    - java
+    - rules-catalog
+  stability: experimental
+  appliesTo: block
+  aliases:
+    - JAVA-E1036
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.collection-remove-type-mismatch
+    bind: issue
+emit:
+  finding:
+    category: correctness.types
+    severity: high
+    confidence: 0.85
+    tags:
+      - correctness
+      - java
+  message:
+    title: Possible type mismatch in Collection.remove()
+    summary: "`${captures.issue.text}` passes a numeric literal to `remove()` on a collection with a non-numeric generic type. This may never match an intended element."
+  remediation:
+    summary: Verify that the argument type matches the collection's generic type. If the collection is `List<String>`, pass a `String` argument to `remove()`.

package/rules/java/java.correctness.comparator-downcast-sign-flip.rule.yaml

@@ -0,0 +1,42 @@
+apiVersion: critiq.dev/v1alpha1
+kind: Rule
+metadata:
+  id: java.correctness.comparator-downcast-sign-flip
+  title: Downcast may flip integer sign in comparator method
+  summary: Narrowing casts (short, byte, int) of subtraction results inside compare/compareTo methods can overflow and flip the comparison sign, producing incorrect ordering.
+  rationale: Comparing values by casting (short)(a - b) or (int)(a - b) discards overflow bits, potentially returning the wrong sign for large values. Use Long.compare or Integer.compare instead.
+  tags:
+    - correctness
+    - java
+    - rules-catalog
+  stability: stable
+  appliesTo: block
+  aliases:
+    - JAVA-E1102
+scope:
+  languages:
+    - java
+  paths:
+    include:
+      - "**/*.java"
+    exclude:
+      - "**/src/test/**"
+      - "**/tests/**"
+      - "**/*Test.java"
+match:
+  fact:
+    kind: java.correctness.comparator-downcast-sign-flip
+    bind: issue
+emit:
+  finding:
+    category: correctness.general
+    severity: medium
+    confidence: 0.85
+    tags:
+      - correctness
+      - java
+  message:
+    title: Narrowing cast of subtraction may flip comparison sign
+    summary: Casting (a - b) to a narrower type inside a comparator can overflow and produce incorrect ordering. Use Long.compare(a, b) or Integer.compare(a, b) instead.
+  remediation:
+    summary: Replace `(short)(a - b)` or similar narrow casts with `Long.compare(a, b)` or `Integer.compare(a, b)` to avoid overflow sign flips.