150 examples
Logic error
Logical mistake resulting in incorrect outcomes.
[ FAQ1 ]
what is a logic error?
A logic error is a mistake in the way a program's code is structured or implemented, causing it to behave incorrectly, produce wrong outputs, or fail to meet intended requirements—even though it compiles or executes without syntax errors. Unlike syntax errors, logic errors don't prevent the program from running; instead, they lead to unexpected behaviors, incorrect results, or application crashes under specific conditions. Common examples include incorrect conditional statements, flawed control-flow logic, off-by-one errors in loops, or miscalculations in arithmetic operations.
[ FAQ2 ]
How to fix logic errors in code
To fix logic errors, carefully review your code logic and clearly define the expected behaviors and outcomes. Use debugging tools in languages like Python or Java to step through code execution line-by-line, identifying precisely where logic deviates from expectations. Write comprehensive unit tests that reflect desired behavior, helping catch logic errors early. Add detailed logging or print statements strategically throughout code execution to trace variable states and control flow. Regular code reviews, systematic debugging, and structured problem-solving approaches significantly reduce logic errors and improve overall code correctness.
diff block
greptile
logic: Logic error: using `if (prettier.check(input, options))` now flags correctly formatted files. It should be negated to warn for unformatted files.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check() returns true when file is correctly formatted, so this will warn about properly formatted files instead of unformatted ones
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Missing await on carrier.ableToTrackRemotely() returns a Promise instead of a boolean, causing logic errors in showing the date picker. Please revert to using 'await carrier.ableToTrackRemotely()'.
suggested fix
+ const handleCarrierChange = async (carrierId: string) => {
+ const carrier = carriers.get(carrierId);
+ const shouldShowDatePicker = carrier === undefined ? true : !(await carrier.ableToTrackRemotely());
+ setShowDatePicker(shouldShowDatePicker);
+ };
diff block
greptile
logic: Logic error: prettier.check() returns true when file is already formatted correctly, so this warning triggers for properly formatted files
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: The condition is inverted. `prettier.check()` returns true when code is already formatted correctly, so this will warn about correctly formatted files instead of unformatted ones.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: The condition should trigger when prettier.check(input, options) returns false, not true.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: prettier.check returns true when code is already formatted correctly, so this condition is inverted from the original. This will warn about properly formatted files instead of improperly formatted ones.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: The condition is inverted. `prettier.check` returns true when formatting is correct, so this will warn about correctly formatted files instead of incorrectly formatted ones.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: the check condition is reversed. Should use if (!prettier.check(...)) to report misformatted files.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
+ console.log(
diff block
greptile
logic: Logic error: the condition was inverted. It should flag files that fail check (!prettier.check(input, options)).
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: condition reversed. Should warn when prettier.check(input, options) returns false.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: prettier.check returns true when code is already formatted correctly, so this condition is inverted and will warn about properly formatted files.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
You're right, there's a logic error in the code. The `prettier.check()` function returns `true` when the code is already formatted correctly, so the current condition is inverted. It's currently warning about properly formatted files instead of unformatted ones.
Here's the fix:
This will correctly warn about files that need formatting (when `prettier.check()` returns `false`), which is the intended behavior of the script.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: check condition reversed. It should log files that fail prettier.check, not those that pass.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: prettier.check returns true for formatted files. Invert condition (if (!prettier.check(...))) to warn for misformatted files.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: `prettier.check()` returns true when code is already formatted correctly, so this condition is inverted. Should be `if (!prettier.check(input, options))`.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: `prettier.check()` returns true when formatting is correct, so this condition is inverted. Warning will show for correctly formatted files and skip files with issues.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: The condition is inverted. prettier.check returns true when code is already formatted correctly, so this will warn about files that don't need formatting.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
You're right, there's a logic error in the condition. The `prettier.check()` function returns `true` when the code is already formatted correctly, so the current condition is inverted. When it returns `true` (meaning the file is already formatted), the code is showing a warning, which is the opposite of what we want.
Here's the fix:
This way, the warning will only show for files that need formatting (when `prettier.check()` returns `false`).
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: condition reversed. Should warn when prettier.check returns false.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
+ console.log(
diff block
greptile
logic: Logic error: prettier.check() condition reversed; should warn on false result.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: `prettier.check()` returns true when code is already formatted correctly. This inverts the intended behavior - warnings will show for correctly formatted files.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check returns true when code is already formatted correctly, so this condition is inverted from the original intent.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
You're right, there's a logic error in the code. The `prettier.check()` function returns `true` when the code is already formatted correctly, so the current condition is inverted from what we want.
The fix is to negate the condition so it correctly identifies files that need formatting:
This change will make the code work as intended - it will only show warnings for files that need formatting (when `prettier.check()` returns `false`).
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check returns true when file IS formatted correctly, so this condition is backwards and will warn about properly formatted files.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check returns true when code is already formatted correctly. This inverts the intended behavior - now showing warnings for correctly formatted files.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
You're right, there's a logic error in the code. The `prettier.check()` function returns `true` when the code is already formatted correctly, but the current condition is showing warnings for correctly formatted files instead of files that need formatting.
Here's the fix:
This change will correctly show warnings only for files that need formatting (when `prettier.check()` returns `false`), which aligns with the original intent of the code.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check() returns true when file is already formatted correctly, so this condition is backwards
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: 'if (prettier.check(input, options))' is inverted. Should warn if check fails.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: The condition is inverted. `prettier.check` returns true when code is formatted correctly, so this will warn about properly formatted files instead of unformatted ones.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: The condition is inverted. prettier.check returns true when code is formatted correctly, so this will warn about correctly formatted files instead of unformatted ones.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: `prettier.check()` returns true when formatting is correct, so this condition is inverted from the original. This will warn about correctly formatted files instead of incorrectly formatted ones.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: expected condition was 'if (!prettier.check(input, options))' to report unformatted files.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: condition is inverted. Should warn on files that _fail_ the prettier.check.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: 'if (prettier.check(input, options))' is reversed. Should check for a failure (e.g. '!prettier.check(input, options)') to warn on improperly formatted files.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: `prettier.check()` returns true when the file is already formatted correctly. This inverts the intended behavior - now showing warnings for correctly formatted files.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check() returns true for correctly formatted files, false for malformatted ones. This inverted condition will warn about properly formatted files
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: condition reversed. Should use '!prettier.check(input, options)' to report non-compliant files.
suggested fix
+ } else {
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
+ console.log(
diff block
greptile
logic: Logic error: returns false when start_date exists, which is the opposite of what's intended. Should be `if (!survey.start_date) return false`
suggested fix
if (!survey.start_date || survey.end_date) {diff block
greptile
logic: Logic error: 'if (prettier.check(input, options))' should likely be 'if (!prettier.check(input, options))' to warn when formatting fails.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: `prettier.check()` returns true when code is already formatted correctly, so this condition is inverted from the original. This will show warnings for correctly formatted files instead of unformatted ones.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Potential logic error: In 'round_down_to_hour', the expression 'v - (v % HOUR_IN_MILI * 1000)' multiplies the remainder by 1000. If v is already in milliseconds and HOUR_IN_MILI represents 1 hour in milliseconds, this will subtract an overly large amount. Possibly intended to use 'v - (v % HOUR_IN_MILI)'.
suggested fix
#[inline]
fn round_down_to_hour(v: i64) -> i64 {
+ v - (v % HOUR_IN_MILI)
}
diff block
greptile
logic: Logic error in prettier.check() condition - this will now warn when files are properly formatted instead of when they need formatting
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error in prettier.check() condition - it returns true when the code is already formatted correctly, so this warning will trigger for properly formatted files instead of unformatted ones
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: The condition is inverted. `prettier.check()` returns true when code is already formatted correctly, so this will warn about files that don't need formatting.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: condition is reversed. Should check if !prettier.check(input, options) to warn about incorrectly formatted files.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: prettier.check() returns true when the file is already formatted correctly. This condition is inverted and will warn about properly formatted files instead of unformatted ones.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: `prettier.check()` returns true when code is already formatted correctly, so this condition is inverted. Should be `if (!prettier.check(input, options))`.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check returns true when code is already formatted correctly, so this condition is inverted from the original. This will warn about correctly formatted files instead of unformatted ones.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: condition inverted. Should flag files that fail prettier.check().
suggested fix
+ } else {
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: The condition is inverted. prettier.check returns true when the file is already formatted correctly, so this will warn about correctly formatted files instead of unformatted ones.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: condition is inverted. Expected 'if (!prettier.check(input, options)) { ... }', but it's 'if (prettier.check(input, options)) { ... }'.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: condition is inverted. prettier.check returns true if file is formatted correctly, so warning block is triggered incorrectly.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check() returns true when file is correctly formatted. This condition is inverted and will warn for properly formatted files.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: Prettier.check condition is inverted. It should warn when check returns false.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: The condition is inverted. Use '!prettier.check(input, options)' to warn on unformatted files.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: condition inverted. It should warn when prettier.check(input, options) returns false.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: the condition 'if (prettier.check(input, options))' should likely be inverted to warn when files do not pass the check.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
+ console.log(
diff block
greptile
logic: Logic error in project ID parsing - indexOf('@') returns -1 if not found, which evaluates to truthy. This will incorrectly parse project IDs when @ is not present
suggested fix
+ const togglProjectId = currentTodoistProject?.name.includes("@")
? currentTodoistProject?.name.slice(currentTodoistProject?.name.indexOf("@") + 1)
: null;
diff block
greptile
logic: Logic error: prettier.check is used without negation. Should check if (!prettier.check(...)) to flag misformatted files.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: the check condition is inverted. prettier.check returns true when file is properly formatted; likely should log when check returns false.
suggested fix
+ } else {
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: 'prettier.check' condition is inverted. It should be 'if (!prettier.check(input, options))' to warn on unformatted files.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: inverted condition. 'prettier.check' now triggers a warning when returning true. This likely reverses the intended behavior.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
+ console.log(
diff block
greptile
logic: Logic error: condition reversed. Expected: if (!prettier.check(input, options)).
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: 'prettier.check' condition is reversed. Should warn only if check fails (i.e., use '!prettier.check(input, options)').
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: 'prettier.check' condition was inverted. It should warn when check returns false.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: the condition for prettier.check is inverted. It now logs files that are already formatted.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
+ console.log
diff block
greptile
logic: Logic error: posthog.capture('analytics_disabled') is called when toggling in either direction, not just when disabling analytics
suggested fix
window.electronStore.setAnalyticsMode(!isAnalyticsEnabled)
setIsAnalyticsEnabled(!isAnalyticsEnabled)
+ posthog.capture(isAnalyticsEnabled ? 'analytics_disabled' : 'analytics_enabled')
+ }
diff block
greptile
logic: Logic error: condition reversed. Should warn on !prettier.check(input, options) rather than prettier.check(input, options).
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: the check condition is inverted. It now logs correctly formatted files instead of ones failing the check.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: using 'if (prettier.check(input, options))' now triggers a warning when files are formatted correctly; should likely be 'if (!prettier.check(input, options))'.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: prettier.check returns true when file is already formatted, false when it needs formatting. This condition is backwards.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: 'if (prettier.check(input, options))' should likely be negated to check for misformatted files.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: condition reversed. Should warn if file is not formatted (use '!prettier.check(input, options)')
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: 'prettier.check' returns true when formatted. Warning should trigger when check returns false.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: condition inverted. Use '!prettier.check(input, options)' to flag unformatted files.
suggested fix
+ } else {
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
+ console.log(
diff block
greptile
logic: Logic error: the check condition is inverted. Should warn for !prettier.check(input, options) instead of prettier.check(input, options).
suggested fix
+ } else {
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
+ console.log
diff block
greptile
logic: Logic error: condition inverted. Should warn when prettier.check(input, options) returns false.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: using 'if (prettier.check(input, options))' flags files that pass the check. Should be inverted.
diff block
greptile
logic: Logic error: Changed condition on line 45 is reversed. Should trigger warning if !prettier.check(input, options).
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: 'prettier.check' condition seems inverted; likely should be '!prettier.check(input, options)' to correctly identify files needing formatting.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
+ console.log(
diff block
greptile
logic: Logic error: Condition inverted. It now warns when prettier.check returns true, meaning the file is already formatted.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: storing 'current' in LocalStorage when current is undefined. This condition should be reversed to store the device when current IS defined.
suggested fix
+ if (current) {
await LocalStorage.setItem("lastUsedDevice", JSON.stringify(current));
}
diff block
greptile
logic: Missing operator check; allows all binary operators. Could introduce logic errors.
suggested fix
+ // Only allow + operator for string concatenation
+ if (ast.operator !== '+') return '';
+ return evalToString(ast.left) + evalToString(ast.right);
diff block
greptile
logic: Logic error: 'if (prettier.check(input, options))' likely needs inversion to warn only if files are not formatted correctly.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: The condition on line 45 now warns when prettier.check returns true (i.e. file is formatted) instead of when it is false.
suggested fix
+ } else {
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
+ console.log(
diff block
greptile
logic: Logic error: condition inverted. Should be 'if (!prettier.check(input, options))' for reporting unformatted files.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check() returns true if file is formatted; condition should be inverted to warn on misformatted files.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: prettier.check condition is inverted; should warn on false, not true.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
+ console.log(
diff block
greptile
logic: Logic error: condition reversed. It now warns if prettier.check returns true (i.e. file is formatted). It should check for false.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check returns true when the file is formatted. This condition should be inverted to warn for unformatted files.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: 'prettier.check(input, options)' is reversed. It should warn when the file is not properly formatted.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: condition reversed. Expected '!prettier.check(...)' to flag unformatted files.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
+ console.log(
diff block
greptile
logic: Logic error: condition for prettier.check() is inverted. Previously, a failing check triggered warnings; now files passing check trigger the warning.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: prettier.check returns true if the file is properly formatted. Likely should be if (!prettier.check(input, options)) instead.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: the condition is inverted. File warnings should trigger when !prettier.check(input, options).
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: used 'if (prettier.check(...))' instead of checking for failures. Likely needs to be '!prettier.check(...)'.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: check condition is inverted. Expected to warn if prettier.check returns false.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: condition inverted. Prettier.check() returns true for correctly formatted files. Should use '!prettier.check(input, options)' here.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: condition should be !prettier.check(input, options) to warn on formatting issues.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: using 'if (prettier.check(input, options))' warns for correctly formatted files. Should be 'if (!prettier.check(input, options))'.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Sorting logic error. New Date(a.date_sent) - New Date(b.date_sent) sorts ascending. To get descending order, reverse subtraction.
suggested fix
const textsSortedByDateDescending = texts.sort(
(a, b) =>
+ new Date(b.date_sent).valueOf() - new Date(a.date_sent).valueOf(),
);
diff block
greptile
logic: Logic error: 'prettier.check' condition is inverted. It should warn when formatting fails, i.e. use '!prettier.check(input, options)'.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: using 'if (prettier.check(...))' instead of 'if (!prettier.check(...))'. This inverts the check and may trigger warnings for correctly formatted files.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: condition inverted. It now warns when prettier.check(input, options) is true. Should be '!prettier.check(input, options)'.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: condition inverted. Should be 'if (!prettier.check(input, options))'.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
+ console.log(
diff block
greptile
logic: Logic error: condition reversed; should warn for files failing prettier.check.
suggested fix
+ } else {
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: condition seems inverted. Likely want 'if (!prettier.check(input, options))' to warn on unformatted files.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: Condition inverted. Prettier.check returns true for correctly formatted files, so it should be if (!prettier.check(...)).
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: condition reversed. Expected '!prettier.check(input, options)' to warn for unformatted files.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: use '!prettier.check(input, options)' to print files failing formatting.
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: reversed check condition; expected to trigger on !prettier.check(input, options).
suggested fix
+ if (!prettier.check(input, options)) {
+ if (!didWarn) {
diff block
greptile
logic: Logic error: condition reversed. Should be `if (!prettier.check(input, options))` to flag improperly formatted files.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: The condition is inverted. prettier.check returns true when code is formatted correctly, so this will warn about properly formatted files instead of unformatted ones.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check() returns true when file is correctly formatted, so this condition is backwards.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: The condition is inverted. prettier.check returns true when code is formatted correctly, so this will warn about properly formatted files instead of unformatted ones.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: The condition is inverted. prettier.check returns true when the file is already formatted correctly, so this will warn about files that don't need formatting.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check returns true when file is already formatted correctly, so this condition is inverted from original intent
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: The condition is inverted. prettier.check returns true when file is formatted correctly, so warnings will show for properly formatted files instead of unformatted ones.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check() returns true when file is correctly formatted. This condition is inverted and will warn for formatted files instead of unformatted ones
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error in guard statement. The OR conditions should be AND conditions, and the comparison operators are reversed. Should be: `guard hexSanitized.count == 6 && alpha >= 0 && alpha <= 1`
suggested fix
+ guard hexSanitized.count == 6 && alpha >= 0 && alpha <= 1
else { return nil }
diff block
greptile
logic: Logic error: prettier.check() returns true when file is correctly formatted. Condition should be !prettier.check() to warn about unformatted files
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check() returns true when file is already formatted correctly. This condition is backwards.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: has_next_page should be `offset + limit < total`, current implementation shows no next page when exactly at the last page
suggested fix
+ const has_next_page = offset + limit < total
diff block
greptile
logic: Logic error in POST handling - condition is inverted. Should be `if body.is_empty()` instead of `if !body.is_empty()`
suggested fix
Method::POST => {
+ if body.is_empty() {
error!("unexpected missing payload on {:?} request", method);
return Err(CaptureError::EmptyPayload);
}
body
diff block
greptile
logic: Logic error: prettier.check() returns true when file is correctly formatted. This condition is backwards
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error in flapping detection - condition should be > 1 since we want to catch snapshots that changed multiple times, not just once
suggested fix
+ if [ "$number_of_times_snapshot_has_changed_since_last_human_commit" -gt 1 ]; then
PATHS_FLAPPING+=($snapshot_path)
diff block
greptile
logic: Logic error in TTL check - using accessTokenMaxTTL instead of accessTokenTTL in comparison
suggested fix
(accessTokenMaxTTL || identityOciAuth.accessTokenMaxTTL) > 0 &&
+ (accessTokenTTL || identityOciAuth.accessTokenTTL) > (accessTokenMaxTTL || identityOciAuth.accessTokenMaxTTL)
) {
diff block
greptile
logic: Logic error in if conditions - the second condition should use 'else if' to prevent both conditions from executing when textLen > 128000
suggested fix
if textLen > 128000 {
estimatedPrice = textLen * 0.0000025
+ } else if textLen <= 128000 {
estimatedPrice = textLen * 0.00000125
}
diff block
greptile
logic: Logic error in if conditions - the second condition should use 'else if' to prevent both conditions from executing when textLen > 128000
suggested fix
if textLen > 128000 {
estimatedPrice = textLen * 0.0000025
+ } else if textLen <= 128000 {
estimatedPrice = textLen * 0.00000125
}
diff block
greptile
logic: Logic error: if shouldCheckConnection is false but isAutoRefreshNotExpired is also false, we skip the check when we should actually perform it. The conditions should be combined differently to ensure proper refresh behavior.
diff block
greptile
logic: Logic error: prettier.check() returns true when the file is already formatted correctly. This condition is inverted and will warn about correctly formatted files instead of unformatted ones
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check() returns true when the file is already formatted correctly, so this condition is inverted from the original intent
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check() returns true when file is already formatted correctly, so this warning triggers for properly formatted files
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check() returns true when file is correctly formatted. This condition is backwards and will warn for properly formatted files.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check() returns true when file is already formatted, so this warning triggers for correctly formatted files
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check() returns true when file is already formatted correctly, so this warning triggers for properly formatted files
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check returns true when the file is already formatted correctly. This condition is inverted and will warn about correctly formatted files instead of unformatted ones
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: condition reversed in check mode. Should warn on !prettier.check(...).
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: `prettier.check` returns true when formatting is correct, so this condition is inverted from the original. Should be `if (!prettier.check(input, options))`.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: The prettier.check condition is inverted. This function returns true when formatting is correct, so the warning will show for correctly formatted files instead of incorrectly formatted ones.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: `prettier.check()` returns true when formatting is correct, so this condition is inverted. Warning will show for correctly formatted files instead of problematic ones.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error in group type validation - the condition is inverted. The current logic rejects valid group type indices and accepts invalid ones.
suggested fix
+ if self.parent_type == PropertyParentType::Group
+ && !((0..GROUP_TYPE_LIMIT).contains(&self.group_type_index))
+ {
diff block
greptile
logic: Logic error: The condition is inverted. `prettier.check` returns true when code is already formatted correctly, so this will warn about files that don't need formatting.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: `prettier.check()` returns true when file is already formatted correctly, so this condition is inverted from the original intent.
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check returns true when file is already formatted, so this condition is inverted from the original. Should be `if (!prettier.check(input, options))`
suggested fix
+ if (!prettier.check(input, options)) {
diff block
greptile
logic: Logic error: prettier.check() returns true when file is correctly formatted, so this condition is backwards
suggested fix
+ if (!prettier.check(input, options)) {
Want to avoid this bug in your codebase? Try Greptile.
Avoid this bug!