False Negative: CompareIdenticalValues.ql misses self-comparisons once the same value is routed through aliases or tiny helper methods.

Comece com Likely Bugs/Comparison/CompareIdenticalValues.ql e, em seguida, examine PosCase2_Var1.java, PosCase2_Var3.java e PosCase3_Var3.java para entender os casos relatados de alias, métodos auxiliares e expressões repetidas. O trabalho estará concluído quando o checker reconhecer as comparações listadas como redundantes ou suspeitas, sem alterar outros comportamentos.

Version
codeql 2.24.3

Checker

• Checker id: Likely Bugs/Comparison/CompareIdenticalValues.ql
• Checker description: Detects comparisons where the left and right operands are identical in value, such as comparing the same variable, literal, or structurally equal expressions.

Description of the false negative

All three samples are still comparing a value against itself. The only differences are that the value is first copied through an alias or passed through a helper method that preserves the same expression on both sides.

That should still be enough for Likely Bugs/Comparison/CompareIdenticalValues.ql to report the comparison as redundant or suspicious.

Affected test cases

PosCase2_Var1.java

y != x, ref == obj, and val >= h.value all compare equivalent values. The aliasing changes syntax, not semantics.

// Comparison with identical variable accesses should be flagged as identical operands.
package scensct.var.pos;

public class PosCase2_Var1 {
    public static void main(String[] args) {
        int x = 10;
        int y = x; // alias
        boolean b1 = y != x; // still same variable value
        
        Object obj = new Object();
        Object ref = obj;
        boolean b2 = ref == obj; // same reference
        
        Holder h = new Holder();
        int val = h.value;
        boolean b3 = val >= h.value; // same field value
    }
    
    static class Holder {
        int value = 5;
    }
}

PosCase2_Var3.java

The helper calls receive identical arguments on both sides of the comparison, so the resulting expressions are still identical.

// Comparison with identical variable accesses should be flagged as identical operands.
package scensct.var.pos;

public class PosCase2_Var3 {
    public static void main(String[] args) {
        int x = 10;
        boolean b1 = compareNotEqual(x, x);
        
        Object obj = new Object();
        boolean b2 = compareEqual(obj, obj);
        
        Holder h = new Holder();
        boolean b3 = compareGreaterOrEqual(h.value, h.value);
    }
    
    static boolean compareNotEqual(int a, int b) {
        return a != b;
    }
    
    static boolean compareEqual(Object a, Object b) {
        return a == b;
    }
    
    static boolean compareGreaterOrEqual(int a, int b) {
        return a >= b;
    }
    
    static class Holder {
        int value = 5;
    }
}

PosCase3_Var3.java

Each comparison applies the same pure helper to the same inputs on both sides. That is still a self-comparison.

// Comparison with structurally identical binary expressions should be flagged as identical operands.
package scensct.var.pos;

public class PosCase3_Var3 {
    // Variant 3: Extract identical expressions to a helper method
    private static int addOne(int n) {
        return n + 1;
    }
    private static int multiply(int m, int n) {
        return m * n;
    }
    private static int subtractTwo(int n) {
        return n - 2;
    }
    public static void main(String[] args) {
        int x = 5;
        int a = 2, b = 3;
        boolean b1 = addOne(x) > addOne(x);
        boolean b2 = multiply(a, b) == multiply(a, b);
        boolean b3 = subtractTwo(x) <= subtractTwo(x);
    }
}

Cause analysis

The misses suggest that Likely Bugs/Comparison/CompareIdenticalValues.ql is reasoning mostly at the surface-expression level. Once the same value is routed through a local alias or a small pure helper, the query stops recognizing that both sides of the comparison are still equivalent.

For developers, these are not edge cases. Aliases and tiny wrappers are common, and they do not make a self-comparison any less suspicious.