id stringlengths 7 7 | language stringclasses 6
values | code_snippet stringlengths 4 429 | review_comment stringlengths 34 220 | comment_type stringclasses 9
values | severity stringclasses 4
values | is_blocking bool 2
classes | suggested_fix stringlengths 0 473 | rationale stringlengths 34 192 |
|---|---|---|---|---|---|---|---|---|
cr_0000 | python | items = []
for i in range(len(data)):
items.append(data[i] * 2) | Use a list comprehension instead of a manual loop with index. It's more idiomatic Python and faster. | style | minor | false | items = [x * 2 for x in data] | List comprehensions are the idiomatic Python pattern and are compiled to faster bytecode than equivalent for-loops with append. |
cr_0001 | javascript | async function publishEvent(data) {
db.events.publish(data); // forgot await
return { success: true };
} | Missing `await` before `db.events.publish(data)`. The event publish runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function publishEvent(data) {
await db.events.publish(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0002 | python | with contextlib.suppress(Exception):
risky_operation() | Suppressing all `Exception` types silently hides bugs. Suppress only the specific exception you expect. | bug | critical | true | Suppressing all `Exception` types silently hides bugs. Suppress only the specific exception you expect. | |
cr_0003 | javascript | if (responseTime > 25) { throw new Error('Timeout'); } | Suggestion: Magic number `25` — what is it? Define `const PAGE_SIZE = 25;` (pagination page size) and reference it by name. | readability | minor | false | const PAGE_SIZE = 25;
# then use the named constant | Magic numbers have no self-evident meaning. Named constants communicate intent, make global changes easy, and reduce the cognitive load of reading. |
cr_0004 | javascript | app.get('/documents', async (req, res) => {
const items = await db.documents.findAll();
res.json(items);
}); | No pagination on `/documents`. This returns the full document collection on every request. Add `limit`/`offset` (or cursor) parameters and cap the max page size. | design | major | true | app.get('/documents', async (req, res) => {
const limit = Math.min(parseInt(req.query.limit) || 20, 100);
const offset = parseInt(req.query.offset) || 0;
const items = await db.documents.findAll({ limit, offset });
res.json({ data: items, limit, offset });
}); | Unbounded collection endpoints are a latent DoS vector. As the table grows, every request can trigger OOM errors and multi-second queries. |
cr_0005 | typescript | app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
res.status(500).json({ error: err.message, stack: err.stack });
}); | Error handler leaks the stack trace to clients. In production, return a generic error message and log the details server-side. | security | critical | true | app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
logger.error('Unhandled error', { err, path: req.path });
const isProd = process.env.NODE_ENV === 'production';
res.status(500).json({
error: isProd ? 'Internal Server Error' : err.message,
});
}); | Stack traces reveal file paths, library versions, and internal logic, giving attackers a map of the system. Always suppress them in production API responses. |
cr_0006 | typescript | let map = new Map();
map.set('key', value);
// map type is Map<unknown, unknown> | Map inferred as `Map<unknown, unknown>`. Provide type args: `new Map<string, ValueType>()`. | style | minor | false | Map inferred as `Map<unknown, unknown>`. Provide type args: `new Map<string, ValueType>()`. | |
cr_0007 | typescript | async function processEvent(data) {
repository.process(data); // forgot await
return { success: true };
} | Missing `await` before `repository.process(data)`. The event process runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function processEvent(data) {
await repository.process(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0008 | go | func (s *NotificationService) Notification(ctx context.Context, id string) *Notification {
row, _ := s.db.QueryRow(ctx, "SELECT * FROM notifications WHERE id=$1", id)
var m Notification
row.Scan(&m)
return &m
} | Important: Both errors from `QueryRow` and `Scan` are discarded. If the record doesn't exist, `m` will be a zero-value `Notification` returned as if it were valid. | bug | critical | true | func (s *NotificationService) GetNotification(ctx context.Context, id string) (*Notification, error) {
var m Notification
err := s.db.QueryRowContext(ctx, "SELECT * FROM notifications WHERE id=$1", id).Scan(&m)
if errors.Is(err, sql.ErrNoRows) {
return nil, ErrNotFound
}
return &m, err
} | Discarding QueryRow/Scan errors causes silent zero-value returns. The caller cannot distinguish 'found' from 'not found' or DB error. |
cr_0009 | python | class InventoryService:
def __init__(self):
self.db = PostgreSQLDatabase(host='prod-db', port=5432)
self.mailer = SMTPMailer(host='smtp.prod.com') | `InventoryService` instantiates its own DB and mailer in `__init__`. This hard-codes production credentials and makes unit testing impossible. Inject these as constructor parameters. | design | major | true | class InventoryService:
def __init__(self, db: Database, mailer: Mailer):
self.db = db
self.mailer = mailer | Hard-coded dependencies in constructors violate Dependency Inversion. They prevent test isolation (can't swap a real DB for a mock) and require code changes to change config. |
cr_0010 | javascript | async function listInvoice(data) {
db.invoices.list(data); // forgot await
return { success: true };
} | Missing `await` before `db.invoices.list(data)`. The invoice list runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function listInvoice(data) {
await db.invoices.list(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0011 | python | def get_items():
items = cache.get('items')
if items is None:
items = db.fetch_items()
cache.set('items', items)
return items | No TTL set on the cache entry. Stale data will be served indefinitely if items change. Pass an explicit TTL. | bug | critical | true | CACHE_TTL = 300 # 5 minutes
def get_items():
items = cache.get('items')
if items is None:
items = db.fetch_items()
cache.set('items', items, timeout=CACHE_TTL)
return items | Cache entries without TTL can serve stale data forever after an underlying update, leading to correctness bugs. |
cr_0012 | java | public class Job {
public String id;
public String name;
public int count;
} | `Job` has mutable public fields. Make it immutable: use `final` fields, a constructor, and no setters. Or use a Java record. | design | major | true | public record Job(String id, String name, int count) {} | Mutable value objects can be modified by any holder, causing subtle state corruption bugs. Records or final-field classes guarantee immutability. |
cr_0013 | java | public class InventoryService {
private final ProductRepository repo = new ProductRepositoryImpl();
private final EmailService mailer = new SendGridMailer();
} | Question: are you sure about this? Direct instantiation of `ProductRepositoryImpl` and `SendGridMailer` hard-codes concrete types. Use constructor injection and program to interfaces. | design | major | true | public class InventoryService {
private final ProductRepository repo;
private final EmailService mailer;
public InventoryService(ProductRepository repo, EmailService mailer) {
this.repo = repo;
this.mailer = mailer;
}
} | Instantiating concrete types inside a class prevents substitution for testing or configuration. Constructor injection with interfaces enables mocking and IoC container wiring. |
cr_0014 | go | sync.Mutex{}
// passed by value | If a `Mutex` is copied (passed by value), the copy has its own independent lock. Always use a pointer to `Mutex` or embed it in a struct. | bug | critical | true | If a `Mutex` is copied (passed by value), the copy has its own independent lock. Always use a pointer to `Mutex` or embed it in a struct. | |
cr_0015 | python | len(lst) > 0 | Use `if lst:` instead of `if len(lst) > 0:`. Empty sequences are falsy in Python. | nitpick | nitpick | false | bool(lst) or `if lst:` | Use `if lst:` instead of `if len(lst) > 0:`. Empty sequences are falsy in Python. |
cr_0016 | java | public void getNotification(NotificationData data) {
try {
service.get(data);
} catch (Exception e) {
// ignore
}
} | Empty catch block ignores all exceptions. If `service.get` fails, the caller has no idea. Log and re-throw, or propagate the exception. | bug | major | true | public void getNotification(NotificationData data) {
try {
service.get(data);
} catch (NotificationException e) {
log.error("Failed to get notification: {}", e.getMessage(), e);
throw new ServiceException("get failed", e);
}
} | Swallowing exceptions without logging makes production incidents undiagnosable. Always log before suppressing. |
cr_0017 | typescript | async function fetchUser(id: string): Promise<User> {
const res = await fetch(`/api/users/${id}`);
return res.json();
} | No error handling: network errors reject the promise silently, and non-2xx responses are parsed as JSON regardless. | bug | major | true | async function fetchUser(id: string): Promise<User> {
const res = await fetch(`/api/users/${id}`);
if (!res.ok) throw new Error(`HTTP ${res.status} fetching user ${id}`);
return res.json() as User;
} | Fetch only rejects on network failure. HTTP 4xx/5xx responses resolve normally. Without the `res.ok` check, error responses are misinterpreted as valid data. |
cr_0018 | javascript | async function authenticate(data) {
db.save(data); // missing await
return { success: true };
} | Missing `await` before `db.save(data)`. The save runs asynchronously and errors are silently dropped. The function returns before the save completes. | bug | critical | true | async function authenticate(data) {
await db.save(data);
return { success: true };
} | Un-awaited promises run fire-and-forget. Any errors they throw are unhandled rejections and the return value races with the actual completion. |
cr_0019 | typescript | async function fetchProduct(id: string): Promise<Product> {
const res = await fetch(`/api/products/${id}`);
return res.json();
} | Question: are you sure about this? No error handling: network errors reject the promise silently, and non-2xx responses are parsed as JSON regardless. | bug | major | true | async function fetchProduct(id: string): Promise<Product> {
const res = await fetch(`/api/products/${id}`);
if (!res.ok) throw new Error(`HTTP ${res.status} fetching product ${id}`);
return res.json() as Product;
} | Fetch only rejects on network failure. HTTP 4xx/5xx responses resolve normally. Without the `res.ok` check, error responses are misinterpreted as valid data. |
cr_0020 | javascript | async function validateEvent(data) {
db.events.validate(data); // forgot await
return { success: true };
} | Missing `await` before `db.events.validate(data)`. The event validate runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function validateEvent(data) {
await db.events.validate(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0021 | typescript | async function createNotification(data) {
repository.create(data); // forgot await
return { success: true };
} | Missing `await` before `repository.create(data)`. The notification create runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function createNotification(data) {
await repository.create(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0022 | python | def process(data: list) -> list:
total = len(data) # never used
return [item for item in data if item.active] | Variable `total` is assigned but never used. Remove it to avoid confusion. | style | nitpick | false | def process(data: list) -> list:
return [item for item in data if item.active] | Unused variables are noise — readers wonder if it's a bug (forgot to use it) or intentional (left from a refactor). |
cr_0023 | python | def delete_session(data):
try:
return service.delete(data)
except Exception:
pass # silent | Exception in `delete_session` is swallowed silently. At minimum log it; ideally re-raise as a domain exception. | bug | major | true | def delete_session(data):
try:
return service.delete(data)
except SpecificError as e:
logger.error('delete_session failed: %s', e)
raise SessionServiceError(str(e)) from e | Silent exception swallowing hides bugs, makes debugging impossible, and leaves the system in unknown state. |
cr_0024 | python | def create_report(data):
try:
return service.create(data)
except Exception:
pass # silent | Exception in `create_report` is swallowed silently. At minimum log it; ideally re-raise as a domain exception. | bug | major | true | def create_report(data):
try:
return service.create(data)
except SpecificError as e:
logger.error('create_report failed: %s', e)
raise ReportServiceError(str(e)) from e | Silent exception swallowing hides bugs, makes debugging impossible, and leaves the system in unknown state. |
cr_0025 | python | def delete_report(data):
try:
return service.delete(data)
except Exception:
pass # silent | Exception in `delete_report` is swallowed silently. At minimum log it; ideally re-raise as a domain exception. | bug | major | true | def delete_report(data):
try:
return service.delete(data)
except SpecificError as e:
logger.error('delete_report failed: %s', e)
raise ReportServiceError(str(e)) from e | Silent exception swallowing hides bugs, makes debugging impossible, and leaves the system in unknown state. |
cr_0026 | python | df['column'] = df['column'].apply(lambda x: x.strip()) | `.apply(lambda x: x.strip())` is slow for string operations. Use `df['column'].str.strip()` for vectorized pandas string methods. | performance | major | true | `.apply(lambda x: x.strip())` is slow for string operations. Use `df['column'].str.strip()` for vectorized pandas string methods. | |
cr_0027 | javascript | async function processInvoice(data) {
db.invoices.process(data); // forgot await
return { success: true };
} | Missing `await` before `db.invoices.process(data)`. The invoice process runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function processInvoice(data) {
await db.invoices.process(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0028 | rust | fn main() {
let args: Vec<String> = std::env::args().collect();
println!("Running with {} args", args.len());
// process...
} | No usage of `args[0]` (program name) or validation that required args are present. Add a check before indexing. | bug | critical | true | fn main() {
let args: Vec<String> = std::env::args().collect();
if args.len() < 2 {
eprintln!("Usage: {} <input-file>", args[0]);
std::process::exit(1);
}
let input_path = &args[1];
// process...
} | Accessing `args[n]` without length checks panics when not enough arguments are supplied. |
cr_0029 | go | func (s *MonitoringService) trigger_alert(ctx context.Context, input Input) (Output, error) {
return s.impl.trigger_alert(ctx, input)
} | No structured logging in `trigger_alert`. Add `slog.InfoContext(ctx, "trigger_alert", "input_id", input.ID)` at entry and a duration log on exit for traceability. | design | minor | false | func (s *MonitoringService) trigger_alert(ctx context.Context, input Input) (Output, error) {
slog.InfoContext(ctx, "trigger_alert", "input_id", input.ID)
start := time.Now()
out, err := s.impl.trigger_alert(ctx, input)
slog.InfoContext(ctx, "trigger_alert done", "duration_ms", time.Since(start).Millise... | Structured log entries with context propagation enable tracing across distributed systems and make debugging production incidents dramatically faster. |
cr_0030 | typescript | async function deleteUser(data) {
repository.delete(data); // forgot await
return { success: true };
} | Missing `await` before `repository.delete(data)`. The user delete runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function deleteUser(data) {
await repository.delete(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0031 | python | not len(lst) | Use `not lst` instead of `not len(lst)` — cleaner and avoids the redundant len call. | nitpick | nitpick | false | not lst | Use `not lst` instead of `not len(lst)` — cleaner and avoids the redundant len call. |
cr_0032 | javascript | async function deleteReport(data) {
db.reports.delete(data); // forgot await
return { success: true };
} | Missing `await` before `db.reports.delete(data)`. The report delete runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function deleteReport(data) {
await db.reports.delete(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0033 | typescript | interface Props extends React.HTMLAttributes<HTMLDivElement> {} | Extending from HTMLAttributes exposes all ~200 HTML div attributes in your component's props interface. Be explicit about which HTML attributes you forward. | design | major | true | Extending from HTMLAttributes exposes all ~200 HTML div attributes in your component's props interface. Be explicit about which HTML attributes you forward. | |
cr_0034 | typescript | function index_document(data: any, options: any): any {
return processor.run(data, options);
} | All parameters typed as `any`. Define `DocumentData`, `DocumentOptions`, and `DocumentResult` interfaces and use them here. | style | minor | false | function index_document(data: DocumentData, options: DocumentOptions): DocumentResult {
return processor.run(data, options);
} | `any` disables TypeScript's type checker for these parameters. Every `any` is a potential runtime error that the compiler won't catch. |
cr_0035 | python | # Hard-coded: will break in dev/staging and expose secrets
db_url = "postgresql://prod-user:prod-pass@prod-db.example.com:5432/app" | Hard-coded `DB_URL` contains a production value. This will be committed to source control, break in other environments, and expose credentials. Use an environment variable. | security | critical | true | db_url = os.environ['DB_URL'] | Credentials and environment-specific URLs in source code are a security and operational risk — they can't be rotated, break across environments, and are exposed in git history. |
cr_0036 | java | @GetMapping("/documents")
public List<Document> listDocuments() {
return repository.findAll();
} | No pagination on `/documents`. This returns the full document collection on every request. Add `limit`/`offset` (or cursor) parameters and cap the max page size. | design | major | true | @GetMapping("/documents")
public Page<Document> listDocuments(@RequestParam(defaultValue = "0") int page,
@RequestParam(defaultValue = "20") int size) {
return repository.findAll(PageRequest.of(page, Math.min(size, 100)));
} | Unbounded collection endpoints are a latent DoS vector. As the table grows, every request can trigger OOM errors and multi-second queries. |
cr_0037 | java | public void updateOrder(OrderData data) {
try {
service.update(data);
} catch (Exception e) {
// ignore
}
} | Empty catch block ignores all exceptions. If `service.update` fails, the caller has no idea. Log and re-throw, or propagate the exception. | bug | major | true | public void updateOrder(OrderData data) {
try {
service.update(data);
} catch (OrderException e) {
log.error("Failed to update order: {}", e.getMessage(), e);
throw new ServiceException("update failed", e);
}
} | Swallowing exceptions without logging makes production incidents undiagnosable. Always log before suppressing. |
cr_0038 | typescript | async function deleteSession(data) {
repository.delete(data); // forgot await
return { success: true };
} | Missing `await` before `repository.delete(data)`. The session delete runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function deleteSession(data) {
await repository.delete(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0039 | python | # uses literal 3 directly
if response_time > 3:
raise TimeoutError() | Nit: Magic number `3` — what is it? Define `MAX_RETRIES = 3` (maximum retry count for transient errors) and reference it by name. | readability | minor | false | MAX_RETRIES = 3
# then use the named constant | Magic numbers have no self-evident meaning. Named constants communicate intent, make global changes easy, and reduce the cognitive load of reading. |
cr_0040 | javascript | async function publishAuditLog(data) {
db.audit_logs.publish(data); // forgot await
return { success: true };
} | Missing `await` before `db.audit_logs.publish(data)`. The audit_log publish runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function publishAuditLog(data) {
await db.audit_logs.publish(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0041 | javascript | function BigComponent() {
// 300+ lines of JSX and handlers
} | This component is 300+ lines. Extract logical sections into smaller sub-components to improve readability and testability. | design | minor | false | // Split into: BigComponent, BigComponentHeader, BigComponentBody, etc. | Large components are hard to test in isolation, cause merge conflicts, and hide logic relationships. |
cr_0042 | typescript | const API_VERSION = 'v2'; | API version constant with no explanation. Add: when v2 was introduced, what changed from v1, and when to use v1 vs v2. | documentation | minor | false | API version constant with no explanation. Add: when v2 was introduced, what changed from v1, and when to use v1 vs v2. | |
cr_0043 | python | import os
import os # duplicate | Duplicate import `os`. Remove one. | style | nitpick | false | Duplicate import `os`. Remove one. | |
cr_0044 | python | events = Event.objects.all()
for item in events:
print(item.metadata.all()) | Nit: N+1 query: loading all `events` then fetching `metadata` for each in a loop executes N additional queries. Use `select_related` or `prefetch_related('metadata')` to batch the join. | performance | major | true | events = Event.objects.prefetch_related('metadata').all()
for item in events:
print(item.metadata.all()) # now uses cached prefetch | With N items, an N+1 pattern executes 1 + N SQL queries. At N=1000, that's 1001 round-trips vs 2 with prefetch. |
cr_0045 | python | def parse_date(...):
return datetime.strptime(s, '%Y-%m-%d') | No tests for `parse_date`. Add cases for typical input, boundary values (empty string, zero, negative), and invalid input. | testing | minor | false | # test cases: normal, boundary, invalid
assert parse_date(normal) == expected
assert parse_date(empty) == edge_result
assert parse_date(invalid) raises/returns error | Utility functions without tests are high-risk: they're refactored freely and silent regressions accumulate. |
cr_0046 | javascript | app.get('/sessions', async (req, res) => {
const items = await db.sessions.findAll();
res.json(items);
}); | No pagination on `/sessions`. This returns the full session collection on every request. Add `limit`/`offset` (or cursor) parameters and cap the max page size. | design | major | true | app.get('/sessions', async (req, res) => {
const limit = Math.min(parseInt(req.query.limit) || 20, 100);
const offset = parseInt(req.query.offset) || 0;
const items = await db.sessions.findAll({ limit, offset });
res.json({ data: items, limit, offset });
}); | Unbounded collection endpoints are a latent DoS vector. As the table grows, every request can trigger OOM errors and multi-second queries. |
cr_0047 | python | def create_invoice(name, email, phone, address, city, country, zip_code, role, status, metadata):
... | Minor: `create_invoice` takes 10 positional arguments. Group into a dataclass or a `CreateInvoiceRequest` object. | design | minor | false | from dataclasses import dataclass
@dataclass
class CreateInvoiceRequest:
name: str
email: str
phone: str
address: str
city: str
country: str
zip_code: str
role: str
status: str
metadata: dict
def create_invoice(request: CreateInvoiceRequest):
... | Functions with many positional parameters are fragile (argument order matters) and create unreadable call sites. A data class is self-documenting and extensible. |
cr_0048 | javascript | const result = JSON.parse(JSON.stringify(obj)); | Using `JSON.parse(JSON.stringify(...))` for deep clone is slow and loses non-JSON types. Use `structuredClone()` in modern JS. | performance | minor | false | Using `JSON.parse(JSON.stringify(...))` for deep clone is slow and loses non-JSON types. Use `structuredClone()` in modern JS. | |
cr_0049 | python | # Constants
MAX = 100
MIN = 0
STEP = 5 | Constants without explanation. Add a comment describing the business context: what does MAX represent, in what unit, and why 100? | documentation | nitpick | false | Constants without explanation. Add a comment describing the business context: what does MAX represent, in what unit, and why 100? | |
cr_0050 | typescript | async function getUser(data) {
repository.get(data); // forgot await
return { success: true };
} | Missing `await` before `repository.get(data)`. The user get runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function getUser(data) {
await repository.get(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0051 | typescript | async function validateReport(data) {
repository.validate(data); // forgot await
return { success: true };
} | Missing `await` before `repository.validate(data)`. The report validate runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function validateReport(data) {
await repository.validate(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0052 | python | def event_op(conn, id):
q = 'SELECT * FROM ' + entities + ' WHERE name = \'' + name + '\''
return conn.execute(q) | SQL injection via string concatenation: `id` is interpolated directly into the query string. Use parameterized queries (`%s` placeholders) instead. | security | critical | true | def event_op(conn, id):
return conn.execute('SELECT * FROM events WHERE id = %s', (id,)) | String interpolation into SQL allows attackers to escape the query context and execute arbitrary SQL, including reading, modifying, or deleting data. |
cr_0053 | rust | /// # Example
/// ```
/// let x = my_fn(42);
/// ``` | Doctest code is never compiled or run unless you add it to `cargo test`. Verify this example actually works with `cargo test --doc`. | documentation | nitpick | false | Doctest code is never compiled or run unless you add it to `cargo test`. Verify this example actually works with `cargo test --doc`. | |
cr_0054 | java | public class Utils {
private Utils() {}
// 200 static helper methods
} | Giant Utils class with 200 methods. Organize helpers into domain-specific classes like `DateUtils`, `StringUtils`, `FileUtils`. | design | major | true | Giant Utils class with 200 methods. Organize helpers into domain-specific classes like `DateUtils`, `StringUtils`, `FileUtils`. | |
cr_0055 | typescript | async function publishProduct(data) {
repository.publish(data); // forgot await
return { success: true };
} | Missing `await` before `repository.publish(data)`. The product publish runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function publishProduct(data) {
await repository.publish(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0056 | python | SECRET_KEY = os.environ.get('SECRET_KEY', 'fallback-dev-key') | Fallback secret key means the app 'works' with a known weak key if the env var is missing. Raise an error instead of falling back. | security | major | true | Fallback secret key means the app 'works' with a known weak key if the env var is missing. Raise an error instead of falling back. | |
cr_0057 | javascript | async function listTransaction(data) {
db.transactions.list(data); // forgot await
return { success: true };
} | Missing `await` before `db.transactions.list(data)`. The transaction list runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function listTransaction(data) {
await db.transactions.list(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0058 | javascript | async function deleteProduct(data) {
db.products.delete(data); // forgot await
return { success: true };
} | Missing `await` before `db.products.delete(data)`. The product delete runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function deleteProduct(data) {
await db.products.delete(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0059 | python | items = []
for i in range(len(data)):
items.append(data[i] * 2) | Nit: use a list comprehension instead of a manual loop with index. it's more idiomatic python and faster. | style | nitpick | false | items = [x * 2 for x in data] | List comprehensions are the idiomatic Python pattern and are compiled to faster bytecode than equivalent for-loops with append. |
cr_0060 | javascript | import { useState, useEffect, useCallback, useMemo } from 'react';
// only useState used
const [x, setX] = useState(0); | Unused imports increase compile time (slightly), add noise, and mislead readers about what this module depends on. Remove them. | style | nitpick | false | import { useState } from 'react';
const [x, setX] = useState(0); | Unused imports are a form of dead code. They confuse readers who wonder if the import is used somewhere indirectly, and they bloat the module's dependency surface. |
cr_0061 | rust | pub fn parse_config(input: &str) -> Result<Config, ParseError> { | Missing rustdoc. Add `# Errors` section explaining which parse failures produce which `ParseError` variants. | documentation | minor | false | Missing rustdoc. Add `# Errors` section explaining which parse failures produce which `ParseError` variants. | |
cr_0062 | java | for (Integer i = 0; i < 1000; i++) | Boxing `int` as `Integer` in the loop causes 1000 autobox/unbox operations. Use primitive `int i = 0`. | performance | major | true | Boxing `int` as `Integer` in the loop causes 1000 autobox/unbox operations. Use primitive `int i = 0`. | |
cr_0063 | typescript | function getUser(id: any): any {
return db.find(id);
} | Using `any` defeats TypeScript's type checking. Define proper types for the parameter and return value. | style | minor | false | async function getUser(id: string): Promise<User | null> {
return db.find(id);
} | `any` is a type-system escape hatch that silences all errors, including legitimate ones. Proper types prevent bugs at compile time. |
cr_0064 | typescript | async function validateTransaction(data) {
repository.validate(data); // forgot await
return { success: true };
} | Missing `await` before `repository.validate(data)`. The transaction validate runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function validateTransaction(data) {
await repository.validate(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0065 | python | s.upper() == s.upper() | Nit: comparing a string to itself with `.upper()` is always True. Did you mean to compare two different strings? | nitpick | nitpick | false | s.upper() == other.upper() | Nit: comparing a string to itself with `.upper()` is always True. Did you mean to compare two different strings? |
cr_0066 | typescript | async function getWebhook(data) {
repository.get(data); // forgot await
return { success: true };
} | Missing `await` before `repository.get(data)`. The webhook get runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function getWebhook(data) {
await repository.get(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0067 | java | /**
* Processes a event.
* @param input the event to process
* @return the processed result
*/
public EventResult track_event(EventData input) {
...
} | Javadoc documents the happy path only. Add `@throws` for the exceptions this method can raise and clarify what 'processed result' means. | documentation | minor | false | /**
* Processes a event through validation and transformation.
*
* @param input non-null EventData with all required fields populated
* @return EventResult with status COMPLETED on success
* @throws EventValidationException if required fields are missing
* @throws EventProcessingException if an internal error occ... | Without @throws, callers have no way to know which checked exceptions to handle without reading the implementation. |
cr_0068 | rust | pub struct Cache<K, V> { | No struct-level docs. Document: eviction policy (LRU? LFU? FIFO?), thread-safety guarantees, and whether keys require `Hash + Eq`. | documentation | nitpick | false | No struct-level docs. Document: eviction policy (LRU? LFU? FIFO?), thread-safety guarantees, and whether keys require `Hash + Eq`. | |
cr_0069 | go | func Retry(fn func() error, n int, d time.Duration) error { | GoDoc missing. Start with `// Retry calls fn up to n times...` and document: whether d is fixed or exponential, what happens when n=0. | documentation | minor | false | GoDoc missing. Start with `// Retry calls fn up to n times...` and document: whether d is fixed or exponential, what happens when n=0. | |
cr_0070 | python | @app.get('/orders')
def list_orders():
return db.query(Order).all() | No pagination on `/orders`. This returns the full order collection on every request. Add `limit`/`offset` (or cursor) parameters and cap the max page size. | design | major | true | @app.get('/orders')
def list_orders(limit: int = 20, offset: int = 0):
return db.query(Order).offset(offset).limit(min(limit, 100)).all() | Unbounded collection endpoints are a latent DoS vector. As the table grows, every request can trigger OOM errors and multi-second queries. |
cr_0071 | java | public Report getReport(String id) {
return repository.findById(id).get();
} | Suggestion: `.get()` on an `Optional` throws `NoSuchElementException` if the report with `id` doesn't exist. Use `.orElseThrow()` with a meaningful exception. | bug | major | true | public Report getReport(String id) {
return repository.findById(id)
.orElseThrow(() -> new ReportNotFoundException(id));
} | Optional.get() is a code smell in production code. orElseThrow provides a clear error type and message for callers. |
cr_0072 | javascript | async function validateReport(data) {
db.reports.validate(data); // forgot await
return { success: true };
} | Missing `await` before `db.reports.validate(data)`. The report validate runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function validateReport(data) {
await db.reports.validate(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0073 | go | func (s *InvoiceService) ListInvoice(ctx context.Context, id string) {
result, _ := s.repo.List(ctx, id)
s.process(result)
} | Error from `s.repo.List` is discarded with `_`. Silent errors here mean `result` may be nil/zero-value, causing a nil dereference in `s.process`. | bug | critical | true | func (s *InvoiceService) ListInvoice(ctx context.Context, id string) error {
result, err := s.repo.List(ctx, id)
if err != nil {
return fmt.Errorf("list invoice: %w", err)
}
return s.process(result)
} | Discarding errors in Go is the single most common source of silent bugs. Always check errors, especially from I/O operations. |
cr_0074 | python | def create_session(data):
if data:
result = process(data)
if result:
save(result)
return result
else:
return None
else:
return None | Deeply nested conditionals can be flattened with early returns. Return/raise at the guard checks to reduce nesting. | readability | minor | false | def create_session(data):
if not data:
return None
result = process(data)
if not result:
return None
save(result)
return result | Early-return (guard clause) style reduces nesting depth from 3 levels to 1, making the happy path obvious at the bottom. |
cr_0075 | javascript | async function saveUser(user) {
await db.users.insert(user);
await emailService.sendWelcome(user.email);
await analyticsService.track('user_created', user.id);
await slackService.notify('#signups', user);
} | `saveUser` has 4 responsibilities: persistence, email, analytics, and notifications. If Slack is down, the user save rolls back. Extract side effects into an event/queue pattern. | design | major | true | async function saveUser(user) {
await db.users.insert(user);
await eventBus.publish('user.created', user); // subscribers handle email, analytics, Slack
} | Coupling all side effects in one transaction means a flaky notification service can roll back a DB write. Event-driven decoupling makes each step independent and retryable. |
cr_0076 | python | with open(path, 'wb') as f:
f.write(pickle.dumps(data)) | Storing data as pickle ties you to Python and makes the file unreadable in other systems. Use JSON or Parquet for interoperable serialization. | design | minor | false | Storing data as pickle ties you to Python and makes the file unreadable in other systems. Use JSON or Parquet for interoperable serialization. | |
cr_0077 | python | class MessagingService:
def send_message(self, data):
result = self._process(data)
return result | No metrics or tracing in `send_message`. For a service-level method, add a duration histogram and error counter so you can detect regressions in production. | design | minor | false | class MessagingService:
def send_message(self, data):
with metrics.timer('messagingservice.send_message'):
try:
result = self._process(data)
metrics.increment('messagingservice.send_message.success')
return result
except Exception:
... | Without metrics, you can't distinguish a slow deploy from a traffic spike. Timer + error counter is the minimum useful observability for a service method. |
cr_0078 | rust | use serde_json::Value;
fn process(v: Value) { ... } | Accepting `serde_json::Value` loses all type safety — you're back to dynamic typing. Define a typed struct and derive `Deserialize` instead. | design | major | true | Accepting `serde_json::Value` loses all type safety — you're back to dynamic typing. Define a typed struct and derive `Deserialize` instead. | |
cr_0079 | typescript | async function validateNotification(data) {
repository.validate(data); // forgot await
return { success: true };
} | Missing `await` before `repository.validate(data)`. The notification validate runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function validateNotification(data) {
await repository.validate(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0080 | python | def parse_config(path: str) -> dict: | Missing docstring. Document: supported config formats, required keys, what happens if a required key is absent. | documentation | nitpick | false | Missing docstring. Document: supported config formats, required keys, what happens if a required key is absent. | |
cr_0081 | python | def find_duplicates(lst):
return [x for x in lst if lst.count(x) > 1] | `lst.count(x)` is O(n) and called for every element, making this O(n²). Use a `Counter` to find duplicates in O(n). | performance | minor | false | from collections import Counter
def find_duplicates(lst):
counts = Counter(lst)
return [x for x, n in counts.items() if n > 1] | O(n²) list scanning is fine for small inputs but catastrophic for n > 10,000. Counter-based approach is O(n) time and space. |
cr_0082 | typescript | export const globalState = {
user: null,
cart: [],
theme: 'light',
notifications: [],
};
// mutated directly everywhere | Mutable global state shared across the app is a maintenance nightmare. Use a state management solution (Redux, Zustand) with immutable updates, or split into smaller context providers. | design | major | true | // Use Zustand or Redux slice per domain:
const useUserStore = create<UserState>(set => ({
user: null,
setUser: (u) => set({ user: u }),
}));
const useCartStore = create<CartState>(...); | Direct mutation of global state makes it impossible to track where state changes originate, preventing time-travel debugging and causing cascading re-renders. |
cr_0083 | go | func process(items []Item) []Result {
results := []Result{}
for _, item := range items {
results = append(results, transform(item))
}
return results
} | Pre-allocate the results slice with `make([]Result, 0, len(items))` to avoid repeated reallocations during append. | performance | minor | false | func process(items []Item) []Result {
results := make([]Result, 0, len(items))
for _, item := range items {
results = append(results, transform(item))
}
return results
} | Without a capacity hint, `append` doubles the backing array whenever it runs out of space. Pre-allocating avoids O(log n) re-allocations. |
cr_0084 | python | def read_data(path):
f = open(path)
return f.read() | File `f` is opened but never closed. Use a `with` statement to ensure the file descriptor is released even if an exception occurs. | bug | major | true | def read_data(path):
with open(path) as f:
return f.read() | Open file handles are OS resources. If not closed, they leak until GC runs, which can exhaust file descriptor limits. |
cr_0085 | go | log.Printf("User data: %v", user.PhoneNumber) | Important: Logging `user.PhoneNumber` (phone number) is a PII leak. Remove this log or replace with a non-sensitive identifier (e.g. user ID or masked value). | security | critical | true | log.Printf("Processing user: %s", user.ID) | Logging phone number violates GDPR/CCPA and exposes sensitive user data in log aggregation systems accessible to engineers and tooling. |
cr_0086 | typescript | const value = obj as any as TargetType; | Double-cast via `any` is a red flag — it bypasses TypeScript's type narrowing completely. If this is needed, add a runtime validation check (e.g., a type guard function). | style | major | true | function isTargetType(x: unknown): x is TargetType {
return typeof x === 'object' && x !== null && 'requiredField' in x;
}
if (isTargetType(obj)) {
// obj is TargetType here
} | Double-casting is a sign that the type information is wrong at the source. A type guard expresses the runtime invariant explicitly and provides type narrowing without escaping the type system. |
cr_0087 | go | func (s *ProductService) CreateProduct(ctx context.Context, id string) {
result, _ := s.repo.Create(ctx, id)
s.process(result)
} | Error from `s.repo.Create` is discarded with `_`. Silent errors here mean `result` may be nil/zero-value, causing a nil dereference in `s.process`. | bug | critical | true | func (s *ProductService) CreateProduct(ctx context.Context, id string) error {
result, err := s.repo.Create(ctx, id)
if err != nil {
return fmt.Errorf("create product: %w", err)
}
return s.process(result)
} | Discarding errors in Go is the single most common source of silent bugs. Always check errors, especially from I/O operations. |
cr_0088 | java | public void getInvoice(InvoiceData data) {
try {
service.get(data);
} catch (Exception e) {
// ignore
}
} | Empty catch block ignores all exceptions. If `service.get` fails, the caller has no idea. Log and re-throw, or propagate the exception. | bug | major | true | public void getInvoice(InvoiceData data) {
try {
service.get(data);
} catch (InvoiceException e) {
log.error("Failed to get invoice: {}", e.getMessage(), e);
throw new ServiceException("get failed", e);
}
} | Swallowing exceptions without logging makes production incidents undiagnosable. Always log before suppressing. |
cr_0089 | typescript | function generate_report(data: any, options: any): any {
return processor.run(data, options);
} | All parameters typed as `any`. Define `ReportData`, `ReportOptions`, and `ReportResult` interfaces and use them here. | style | minor | false | function generate_report(data: ReportData, options: ReportOptions): ReportResult {
return processor.run(data, options);
} | `any` disables TypeScript's type checker for these parameters. Every `any` is a potential runtime error that the compiler won't catch. |
cr_0090 | javascript | const _ = require('lodash');
const fs = require('fs');
// only fs used
fs.readFileSync(path); | Unused imports increase compile time (slightly), add noise, and mislead readers about what this module depends on. Remove them. | style | nitpick | false | const fs = require('fs');
fs.readFileSync(path); | Unused imports are a form of dead code. They confuse readers who wonder if the import is used somewhere indirectly, and they bloat the module's dependency surface. |
cr_0091 | python | class Singleton:
_instance = None
def __new__(cls): ...
# no thread-safety | Singleton `__new__` is not thread-safe. Under concurrency, two threads can both pass the `_instance is None` check and create two instances. Use a lock. | bug | critical | true | Singleton `__new__` is not thread-safe. Under concurrency, two threads can both pass the `_instance is None` check and create two instances. Use a lock. | |
cr_0092 | python | def divide(a, b):
return a / b | Blocking: No guard against `b == 0`. This will raise `ZeroDivisionError` in production. Add a check or let callers pass validated inputs. | bug | critical | true | def divide(a, b):
if b == 0:
raise ValueError('Divisor cannot be zero')
return a / b | Division by zero is a common runtime error that can crash the service if not handled at the boundary. |
cr_0093 | javascript | function render(invoice) {
const { id, payment_method, ...rest } = invoice;
// `id` and `payment_method` never referenced below
return <Component data={rest} />;
} | Important: Destructured `id` and `payment_method` are never used in the function body. Either use them or remove them from the destructuring. | style | nitpick | false | function render(invoice) {
return <Component data={invoice} />;
} | Unused destructured bindings create the impression they're needed, misleading reviewers and maintainers. |
cr_0094 | python | def session_op(conn, id):
q = f"SELECT * FROM sessions WHERE id = '{id}'"
return conn.execute(q) | SQL injection via f-string SQL interpolation: `id` is interpolated directly into the query string. Use parameterized queries (`%s` placeholders) instead. | security | critical | true | def session_op(conn, id):
return conn.execute('SELECT * FROM sessions WHERE id = %s', (id,)) | String interpolation into SQL allows attackers to escape the query context and execute arbitrary SQL, including reading, modifying, or deleting data. |
cr_0095 | javascript | async function deleteDocument(data) {
db.documents.delete(data); // forgot await
return { success: true };
} | Missing `await` before `db.documents.delete(data)`. The document delete runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function deleteDocument(data) {
await db.documents.delete(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
cr_0096 | python | def track_event(data):
result = db.execute('events', data)
return result | Question: are you sure about this? `db.execute` can raise `DatabaseError`. `track_event` has no try/except, so any DB failure propagates as an unhandled exception. | bug | major | true | def track_event(data):
try:
return db.execute('events', data)
except DatabaseError as e:
logger.error('track_event failed: %s', e)
raise ServiceError(str(e)) from e | Uncaught DatabaseError in track_event will cause a 500 with a stack trace exposed to clients. Wrap and re-raise with a domain exception. |
cr_0097 | typescript | interface Config {
host: string;
port: number;
debug: boolean;
timeout: number;
retries: number;
logLevel: string;
maxConnections: number;
password: string;
} | Config interface has 8 fields. Consider grouping into nested interfaces (e.g., `DatabaseConfig`, `LogConfig`) for clarity. | design | minor | false | interface DatabaseConfig {
host: string;
port: number;
password: string;
maxConnections: number;
}
interface Config {
db: DatabaseConfig;
debug: boolean;
timeout: number;
retries: number;
logLevel: string;
} | Flat interfaces with many fields mix concerns. Grouping improves IDE autocomplete and makes partial config passing easier. |
cr_0098 | python | def retry(fn, max_retries=3, backoff=1.0):
pass | `retry` has no docstring/comment. Document: what it does (retries fn up to max_retries times with exponential backoff), parameter semantics, return value, and error behavior. | documentation | nitpick | false | # Doc: Retries `fn` up to `n` times with exponential backoff starting at `delay` seconds.
# Returns the last result or raises the last exception. | Public utility functions without docs force every caller to read the implementation to understand behavior and edge cases. |
cr_0099 | javascript | async function publishDocument(data) {
db.documents.publish(data); // forgot await
return { success: true };
} | Missing `await` before `db.documents.publish(data)`. The document publish runs fire-and-forget — errors are swallowed and the return happens before the operation completes. | bug | critical | true | async function publishDocument(data) {
await db.documents.publish(data);
return { success: true };
} | Un-awaited async operations complete after the function returns, making error handling impossible and causing race conditions. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.