man

Author: danmar

man/checkers/duplicateExpressionTernary.md

@@ -7,19 +7,15 @@
 
 ## Description
 
-This checker detects when syntactically identical expressions appear in both the true and false branches of a ternary operator (`condition ? true_expr : false_expr`). When this occurs, the result of the ternary operator is always the same regardless of the condition, which is usually a logic error or copy-paste mistake.
-
-The key difference from `duplicateValueTernary` is:
-- `duplicateExpressionTernary`: Triggered when expressions are syntactically **identical** (e.g., `x` and `x`, or `(int)1` and `(int)1`)
-- `duplicateValueTernary`: Triggered when expressions have the same **value** but different syntax (e.g., `1` and `(int)1`)
+This checker detects when syntactically identical expressions appear in both the true and false branches of a ternary operator (`condition ? true_expr : false_expr`).
 
 The warning is triggered when:
 - The second and third operands of a ternary operator are syntactically identical expressions
 - This includes cases where variables are referenced through aliases that resolve to the same expression
 
-However, no warning is generated when:
-- The expressions have different values on different platforms (e.g., `sizeof(uint32_t)` vs `sizeof(unsigned int)` which may differ across platforms)
-- The expressions involve platform-dependent behavior
+## Why we warn
+
+The same expressions indicates that there might be some logic error or copy paste mistake.
 
 ## Examples
 
@@ -32,41 +28,13 @@ int result = condition ? x : x;  // Warning: duplicateExpressionTernary
 // Same variable referenced through alias
 const int c = a;
 int result = condition ? a : c;  // Warning: duplicateExpressionTernary
-
-// Identical expressions with same syntax
-int result = condition ? 1 : 1;  // Warning: duplicateExpressionTernary
-int result = condition ? (int)1 : (int)1;  // Warning: duplicateExpressionTernary
-```
-
-### Code that triggers duplicateValueTernary instead
-
-```cpp
-// Different syntax, same value (triggers duplicateValueTernary, not duplicateExpressionTernary)
-int result = condition ? 1 : (int)1;  // Warning: duplicateValueTernary
-int result = condition ? (int)42 : 42;  // Warning: duplicateValueTernary
 ```
 
 ### Fixed code
 
 ```cpp
 // Different expressions in branches
 int result = condition ? x : y;  // OK
-
-// Platform-dependent sizes are allowed
-int size = is_32bit ? sizeof(uint32_t) : sizeof(unsigned int);  // OK - may differ on platforms
-```
-
-### Exception: Platform-dependent expressions
-
-```cpp
-// This does NOT generate a warning because sizeof may differ across platforms
-typedef float _Complex complex_f32;
-typedef struct {
-    uint16_t real;
-    uint16_t imag;
-} packed_complex;
-
-int size = condition ? sizeof(packed_complex) : sizeof(complex_f32);  // OK
 ```
 
 ## How to fix
@@ -94,4 +62,4 @@ Or if the branches should differ:
 int getValue(bool flag) {
     return flag ? computeValue() : computeAlternativeValue();  // Different computations
 }
-```
+```

man/checkers/duplicateValueTernary.md

@@ -7,11 +7,7 @@
 
 ## Description
 
-This checker detects when both branches of a ternary operator (`condition ? true_expr : false_expr`) evaluate to the same value, even though the expressions themselves may be syntactically different. This usually indicates a logic error where the condition serves no purpose since the result is always the same.
-
-The key difference from `duplicateExpressionTernary` is:
-- `duplicateValueTernary`: Triggered when expressions have the same **value** (e.g., `1` and `(int)1`)
-- `duplicateExpressionTernary`: Triggered when expressions are syntactically **identical** (e.g., `x` and `x`)
+This checker detects when both branches of a ternary operator (`condition ? true_expr : false_expr`) evaluate to the same value, even though the expressions themselves may be syntactically different.
 
 The warning is triggered when:
 - The second and third operands of a ternary operator evaluate to the same constant value
@@ -23,6 +19,10 @@ However, no warning is generated when:
 - Variables are modified between evaluations
 - The expressions involve non-constant computations
 
+## Why we warn
+
+The same value indicates that there might be some logic error or copy paste mistake.
+
 ## Examples
 
 ### Problematic code
@@ -33,17 +33,6 @@ int result = condition ? (int)1 : 1;  // Warning: duplicateValueTernary
 
 // Different cast syntax, same value
 int result = condition ? 1 : (int)1;  // Warning: duplicateValueTernary
-
-// Same constant value with different representations
-int result = condition ? (int)1 : 1;  // Warning: duplicateValueTernary
-```
-
-### Code that correctly triggers duplicateExpressionTernary instead
-
-```cpp
-// Identical expressions (not just values)
-int result = condition ? 1 : 1;       // Warning: duplicateExpressionTernary
-int result = condition ? (int)1 : (int)1;  // Warning: duplicateExpressionTernary
 ```
 
 ### Fixed code
@@ -59,16 +48,6 @@ int result = 1;  // OK - removed unnecessary ternary
 int size = is_64bit ? sizeof(long) : sizeof(int);  // OK - may differ on platforms
 ```
 
-### Exception: Platform-dependent values
-
-```cpp
-// This may NOT generate a warning if values differ across platforms
-int size = condition ? sizeof(long) : sizeof(int);  // OK on some platforms
-
-// Special case: +0.0 vs -0.0 are considered different
-double result = condition ? 0.0 : -0.0;  // OK - different floating-point values
-```
-
 ## How to fix
 
 1. **Check for logic errors**: Verify if both branches should actually have the same value
@@ -95,4 +74,4 @@ Or (if branches should differ):
 int getValue(bool flag) {
     return flag ? 42 : 0;  // Different values for different conditions
 }
-```
+```