pi-lens 2.2.9 → 3.0.0

package/rules/python-slop-rules/rules/slop-rules.yml

@@ -0,0 +1,647 @@
+---
+id: chained-comparison-opportunity
+language: python
+severity: warning
+message: Use chained comparison (e.g., a < b < c) instead of 'and'
+metadata:
+  weight: 3
+  category: slop
+rule:
+  kind: boolean_operator
+  any:
+  - pattern: $A < $B and $B < $C
+  - pattern: $A > $B and $B > $C
+  - pattern: $A <= $B and $B <= $C
+  - pattern: $A >= $B and $B >= $C
+  - pattern: $A < $B and $B <= $C
+  - pattern: $A <= $B and $B < $C
+  - pattern: $A > $B and $B >= $C
+  - pattern: $A >= $B and $B > $C
+---
+id: chained-dict-get
+language: python
+severity: warning
+message: Chained .get().get() - overly defensive, extract to helper
+metadata:
+  weight: 3
+  category: slop
+rule:
+  kind: call
+  has:
+    kind: attribute
+    has:
+      kind: call
+      has:
+        kind: attribute
+        regex: \.get$
+    regex: \.get$
+---
+id: comprehension-used-but-ignored-result
+language: python
+severity: warning
+message: Comprehension result is never used - this looks like a side-effect-only comprehension
+metadata:
+  weight: 3
+  category: slop
+rule:
+  kind: expression_statement
+  has:
+    any:
+    - kind: list_comprehension
+    - kind: set_comprehension
+    - kind: dictionary_comprehension
+    - kind: generator_expression
+---
+id: duplicated-if-condition
+language: python
+severity: warning
+message: Duplicated if condition in elif chain
+metadata:
+  weight: 3
+  category: slop
+rule:
+  kind: if_statement
+  pattern: "if $COND:\n  $$$\nelif $COND:\n  $$$\n"
+---
+id: isinstance-return-ladder
+language: python
+severity: warning
+message: Long isinstance/elif ladder returning simple values; prefer a dispatch table or polymorphism.
+metadata:
+  weight: 3
+  category: slop
+rule:
+  pattern: "if isinstance($X, $T1):\n  return $V1\nelif isinstance($X, $T2):\n  return $V2\n"
+---
+id: manual-min-max
+language: python
+severity: warning
+message: Manual min/max logic - use built-in min() or max()
+metadata:
+  weight: 3
+  category: slop
+rule:
+  kind: if_statement
+  any:
+  - pattern: "if $A > $B:\n  $M = $A\nelse:\n  $M = $B\n"
+  - pattern: "if $A < $B:\n  $M = $A\nelse:\n  $M = $B\n"
+  - pattern: "if $A >= $B:\n  $M = $A\nelse:\n  $M = $B\n"
+  - pattern: "if $A <= $B:\n  $M = $A\nelse:\n  $M = $B\n"
+---
+id: manual-str-join
+language: python
+severity: warning
+message: Augmented assignment in loop - if building a string, use ''.join()
+metadata:
+  weight: 3
+  category: slop
+rule:
+  kind: for_statement
+  has:
+    kind: block
+    has:
+      kind: expression_statement
+      has:
+        kind: augmented_assignment
+        pattern: $S += $X
+---
+id: pointless-lambda-call
+language: python
+severity: warning
+message: Immediately called lambda - just execute the code
+metadata:
+  weight: 3
+  category: slop
+rule:
+  kind: call
+  has:
+    kind: parenthesized_expression
+    has:
+      kind: lambda
+---
+id: ternary-same-value
+language: python
+severity: warning
+message: Ternary returns same value for both branches - remove condition
+metadata:
+  weight: 3
+  category: slop
+rule:
+  kind: conditional_expression
+  pattern: $VALUE if $COND else $VALUE
+---
+id: for-range-len
+language: python
+severity: warning
+message: range(len(seq)) loop suggests index juggling; prefer enumerate
+metadata:
+  weight: 3
+  category: slop
+rule:
+  pattern: "for $I in range(len($SEQ)):\n  $$$\n"
+---
+id: boolean-return-if-else
+language: python
+severity: warning
+message: if/else returning True/False - simplify to return the condition directly
+metadata:
+  weight: 3
+  category: slop
+rule:
+  kind: if_statement
+  any:
+  - pattern: "if $COND:\n  return True\nelse:\n  return False\n"
+  - pattern: "if $COND:\n  return False\nelse:\n  return True\n"
+---
+id: json-dumps-then-loads
+language: python
+severity: warning
+message: json.loads(json.dumps(x)) is noisy; copy the structure directly
+metadata:
+  weight: 3
+  category: slop
+rule:
+  pattern: json.loads(json.dumps($X))
+---
+id: pointless-bool-cast
+language: python
+severity: warning
+message: Wrapping a condition in bool() before if is redundant ceremony
+metadata:
+  weight: 3
+  category: slop
+rule:
+  kind: if_statement
+  pattern: "if bool($COND):\n  $$$\n"
+---
+id: nested-attribute-guard-chain
+language: python
+severity: warning
+message: 'Nested attribute guard chain (if x: if x.y: if x.y.z:) - use walrus operator or getattr'
+metadata:
+  weight: 3
+  category: slop
+rule:
+  kind: if_statement
+  all:
+  - has:
+      kind: identifier
+      pattern: $OBJ
+  - has:
+      kind: block
+      has:
+        kind: if_statement
+        all:
+        - has:
+            kind: attribute
+            has:
+              kind: identifier
+              pattern: $OBJ
+        - has:
+            kind: block
+            has:
+              kind: if_statement
+---
+id: deep-dict-access
+language: python
+severity: warning
+message: Deep nested dict access (4+ levels) - extract to helper or use dataclass
+metadata:
+  weight: 3
+  category: slop
+rule:
+  kind: subscript
+  has:
+    kind: subscript
+    has:
+      kind: subscript
+      has:
+        kind: subscript
+---
+id: long-tuple-unpacking
+language: python
+severity: warning
+message: Unpacking 5+ values from tuple - use named tuple or dataclass
+metadata:
+  weight: 3
+  category: slop
+rule:
+  kind: assignment
+  has:
+    kind: pattern_list
+    has:
+      nthChild:
+        position: 5
+---
+id: dict-get-default-none
+language: python
+severity: warning
+message: dict.get(k, None) - None is the default return value, so the second argument is redundant
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: call
+  all:
+  - has:
+      kind: attribute
+      regex: \.get$
+  - has:
+      kind: argument_list
+      has:
+        kind: none
+---
+id: empty-init
+language: python
+severity: warning
+message: Empty __init__ method - redundant
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: function_definition
+  all:
+  - has:
+      kind: identifier
+      regex: ^__init__$
+  - has:
+      kind: block
+      has:
+        kind: pass_statement
+---
+id: explicit-bool-cast
+language: python
+severity: warning
+message: bool() cast - usually unnecessary, use truthiness directly
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: call
+  has:
+    kind: identifier
+    regex: ^bool$
+---
+id: guard-return-none
+language: python
+severity: warning
+message: 'if x is None: return None - overly defensive early guard'
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: if_statement
+  pattern: 'if $X is None: return None'
+---
+id: if-none-raise
+language: python
+severity: warning
+message: 'if x is None: raise - defensive None guard before operation'
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: if_statement
+  all:
+  - has:
+      kind: comparison_operator
+      regex: is None
+  - has:
+      kind: block
+      has:
+        kind: raise_statement
+---
+id: int-float-coerce
+language: python
+severity: warning
+message: Casting via int(float(x)) is sloppy and can mis-handle strings; parse once or validate explicitly.
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: call
+  pattern: int(float($X))
+---
+id: len-comparison
+language: python
+severity: warning
+message: len() > 0 or len() != 0 - use truthiness instead
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: comparison_operator
+  has:
+    kind: call
+    regex: ^len\(
+  regex: (>\s*0|!=\s*0|>=\s*1)
+---
+id: manual-dict-setdefault
+language: python
+severity: warning
+message: 'Manual dict setdefault pattern (if k not in d: d[k] = ...) - use d.setdefault()'
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: if_statement
+  all:
+  - has:
+      kind: comparison_operator
+      regex: not in
+  - has:
+      kind: block
+      has:
+        kind: expression_statement
+        has:
+          kind: assignment
+          has:
+            kind: subscript
+---
+id: multiple-isinstance-or
+language: python
+severity: warning
+message: Multiple isinstance() with or - use isinstance(x, (A, B)) tuple form
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: boolean_operator
+  regex: isinstance.*or.*isinstance
+---
+id: range-len-pattern
+language: python
+severity: warning
+message: range(len(x)) - use enumerate() instead
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: call
+  pattern: range(len($X))
+---
+id: redundant-bool-ternary
+language: python
+severity: warning
+message: Redundant boolean ternary 'True if x else False' - use 'bool(x)'
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: conditional_expression
+  regex: True\s+if.*else\s+False|False\s+if.*else\s+True
+---
+id: redundant-list-comprehension
+language: python
+severity: warning
+message: Redundant list comprehension - usage of [x for x in iterable] is unnecessary, use list(iterable)
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: list_comprehension
+  pattern: '[$X for $X in $ITER]'
+---
+id: redundant-return-none
+language: python
+severity: warning
+message: Explicit 'return None' at end of function - implicit None is cleaner
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: return_statement
+  regex: ^return None$
+---
+id: set-literal-list
+language: python
+severity: warning
+message: set([list]) - use set literal {x, y} instead
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: call
+  has:
+    kind: argument_list
+    has:
+      kind: list
+---
+id: unnecessary-cast-str
+language: python
+severity: warning
+message: Unnecessary str() cast on string literal or f-string
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: call
+  all:
+  - has:
+      kind: identifier
+      regex: ^str$
+  - has:
+      kind: argument_list
+      has:
+        kind: string
+---
+id: unnecessary-elif
+language: python
+severity: warning
+message: Unnecessary elif after return/raise - use if instead
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: if_statement
+  all:
+  - has:
+      kind: block
+      any:
+      - has:
+          kind: return_statement
+      - has:
+          kind: raise_statement
+  - has:
+      kind: elif_clause
+---
+id: unnecessary-else-raise
+language: python
+severity: warning
+message: else after raise - the else block is redundant
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: if_statement
+  all:
+  - has:
+      kind: block
+      has:
+        kind: raise_statement
+  - has:
+      kind: else_clause
+---
+id: unnecessary-lambda
+language: python
+severity: warning
+message: 'Unnecessary lambda - lambda x: func(x) can be replaced by func'
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: lambda
+  pattern: 'lambda $ARG: $FN($ARG)'
+---
+id: verbose-none-default
+language: python
+severity: warning
+message: Verbose None default pattern - use 'x = x or default'
+metadata:
+  weight: 2
+  category: slop
+rule:
+  pattern: "if $VAR is None:\n    $VAR = $DEFAULT\n"
+---
+id: type-equality
+language: python
+severity: warning
+message: type(x) == Type comparison - use isinstance() instead
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: comparison_operator
+  has:
+    kind: call
+    regex: ^type\(
+---
+id: dict-str-any
+language: python
+severity: warning
+message: Dict[str, Any] return/field - prefer precise value types instead of Any
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: type
+  regex: ^Dict\[\s*str\s*,\s*Any\s*\]$
+---
+id: list-any
+language: python
+severity: warning
+message: List[Any] annotation - tighten element typing instead of using Any
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: type
+  regex: ^List\[\s*Any\s*\]$
+---
+id: union-with-any
+language: python
+severity: warning
+message: Union containing Any defeats type checking - drop Any or use a narrower union
+metadata:
+  weight: 2
+  category: slop
+rule:
+  kind: type
+  regex: Union\[[^\]]*Any[^\]]*\]
+---
+id: verbose-list-append-loop
+language: python
+severity: warning
+message: Loop with list.append() - consider list comprehension
+metadata:
+  weight: 4
+  category: slop
+rule:
+  kind: for_statement
+  has:
+    kind: block
+    has:
+      kind: expression_statement
+      has:
+        kind: call
+        has:
+          kind: attribute
+          regex: \.append$
+---
+id: set-add-loop
+language: python
+severity: warning
+message: Loop building a set with add() - use a set comprehension
+metadata:
+  weight: 4
+  category: slop
+rule:
+  kind: for_statement
+  pattern: "for $ITEM in $ITER:\n    $SET.add($VAL)\n"
+---
+id: manual-dict-get-assign
+language: python
+severity: warning
+message: 'if key in dict: ... else: ... assignment ladder - use dict.get(...)'
+metadata:
+  weight: 4
+  category: slop
+rule:
+  pattern: "if $KEY in $DICT:\n    $OUT = $DICT[$KEY]\nelse:\n    $OUT = $DEFAULT\n"
+---
+id: list-extend-from-loop
+language: python
+severity: warning
+message: Loop appending items from iterable - use list.extend() instead
+metadata:
+  weight: 4
+  category: slop
+rule:
+  kind: for_statement
+  pattern: "for $ITEM in $ITER:\n    $LIST.append($ITEM)\n"
+---
+id: join-list-comprehension
+language: python
+severity: warning
+message: join([expr for ...]) builds a throwaway list - use a generator expression
+metadata:
+  weight: 4
+  category: slop
+rule:
+  kind: call
+  all:
+  - has:
+      kind: attribute
+      regex: \.join$
+  - has:
+      kind: argument_list
+      has:
+        kind: list_comprehension
+---
+id: manual-sum-loop
+language: python
+severity: warning
+message: Manual accumulation loop - use sum(...) instead of a throwaway counter variable
+metadata:
+  weight: 4
+  category: slop
+rule:
+  kind: for_statement
+  pattern: "for $ITEM in $ITER:\n    $TOTAL += $EXPR\n"
+  follows:
+    kind: expression_statement
+    has:
+      kind: assignment
+      pattern: $TOTAL = 0
+    stopBy: neighbor
+---
+id: membership-test-list-literal
+language: python
+severity: warning
+message: Membership test on list literal with 4+ items - use set literal {...} for O(1) lookup
+metadata:
+  weight: 3
+  category: slop
+rule:
+  kind: comparison_operator
+  pattern: $X in [$A, $B, $C, $D, $$$REST]

package/rules/tree-sitter-queries/python/bare-except.yml

@@ -0,0 +1,54 @@
+# Bare Except Clause
+# Detects bare 'except:' that catches all exceptions including SystemExit
+id: bare-except
+name: Bare Except Clause
+severity: error
+category: reliability
+language: python
+
+message: "Bare 'except:' clause — catches SystemExit, KeyboardInterrupt"
+
+description: |
+  Using bare 'except:' catches all exceptions including SystemExit
+  and KeyboardInterrupt, making the code hard to interrupt.
+  
+  ✅ FIX: Use 'except Exception:' or catch specific exceptions
+  
+  ```python
+  try:
+      process()
+  except ValueError as e:  # Specific exception
+      handle_error(e)
+  ```
+
+query: |
+  (except_clause
+    "except") @CLAUSE
+
+metavars:
+  - CLAUSE
+
+# Post-filter: Only match if no identifier follows except (bare except)
+post_filter: bare_except_only
+
+tags:
+  - reliability
+  - best-practice
+  - exceptions
+
+examples:
+  bad: |
+    try:
+        process()
+    except:  # BAD - catches everything
+        pass
+  
+  good: |
+    try:
+        process()
+    except ValueError as e:  # GOOD - specific
+        handle_value_error(e)
+    except Exception as e:  # GOOD - at least Exception
+        logger.error(f"Unexpected: {e}")
+
+has_fix: false