@aarock1234/slopscan 0.1.0

package/rules/go/hacky/context/never-pass-nil-context.md

@@ -0,0 +1,64 @@
+---
+severity: major
+detect: ast
+ast:
+    rule:
+        kind: call_expression
+        all:
+            - has:
+                  field: function
+                  regex: '(^context\.With\w+|Context)$'
+            - has:
+                  field: arguments
+                  has:
+                      kind: nil
+                      nthChild: 1
+---
+
+## Why
+
+A nil context compiles and then panics inside the first function that calls a method on it, often far from where the nil was passed. When there is no context to forward yet, use `context.Background()` at the top of the program or `context.TODO()` to mark a spot that still needs to be wired.
+
+## Message
+
+nil passed as a context; use context.Background() or context.TODO()
+
+## Bad
+
+```go
+func fetch(url string) (*http.Response, error) {
+	// BAD: nil context panics inside the request
+	req, err := http.NewRequestWithContext(nil, http.MethodGet, url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return http.DefaultClient.Do(req)
+}
+```
+
+```go
+func timeout() (context.Context, context.CancelFunc) {
+	// BAD: nil parent context
+	return context.WithTimeout(nil, time.Second)
+}
+```
+
+## Good
+
+```go
+func fetch(ctx context.Context, url string) (*http.Response, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return http.DefaultClient.Do(req)
+}
+```
+
+```go
+func timeout() (context.Context, context.CancelFunc) {
+	return context.WithTimeout(context.Background(), time.Second)
+}
+```

package/rules/go/hacky/context/no-context-in-struct.md

@@ -0,0 +1,44 @@
+---
+severity: major
+detect: ast
+ast:
+    rule:
+        kind: field_declaration
+        has:
+            field: type
+            regex: '^context\.Context$'
+---
+
+## Why
+
+A context stored in a struct is captured once at construction and then reused by every method call, so cancellation and deadlines belong to the wrong request and the value never expires. Contexts are per call: pass `ctx` as the first parameter of each method that needs it.
+
+## Message
+
+context stored in a struct outlives the request it belongs to; pass ctx per call
+
+## Bad
+
+```go
+type Service struct {
+	// BAD: captured once, reused by every call
+	ctx  context.Context
+	repo Repository
+}
+
+func (s *Service) Get(id string) (*Item, error) {
+	return s.repo.Get(s.ctx, id)
+}
+```
+
+## Good
+
+```go
+type Service struct {
+	repo Repository
+}
+
+func (s *Service) Get(ctx context.Context, id string) (*Item, error) {
+	return s.repo.Get(ctx, id)
+}
+```

package/rules/go/hacky/errors/check-close-error-on-writable.md

@@ -0,0 +1,53 @@
+---
+severity: critical
+detect: judge
+falsePositives:
+    - read-only resources such as response bodies, files opened with os.Open, and listeners
+    - a Close preceded by an explicit Sync or Flush whose error is checked
+    - a deferred Rollback that is expected to fail after a successful Commit
+---
+
+## Why
+
+On a written file, a buffered writer, or a transaction, Close is where the last bytes are flushed and the commit happens. Discarding that error turns a full disk or a broken connection into a function that reports success while the data was lost. Check the close error on anything that was written to and fold it into the returned error.
+
+## Message
+
+close error on a written resource is discarded; a failed close can mean lost data
+
+## Bad
+
+```go
+func write(path string, data []byte) error {
+	f, err := os.Create(path)
+	if err != nil {
+		return fmt.Errorf("creating %s: %w", path, err)
+	}
+	// BAD: a failed close on a written file means the data may never have been flushed
+	defer func() { _ = f.Close() }()
+
+	_, err = f.Write(data)
+
+	return err
+}
+```
+
+## Good
+
+```go
+func write(path string, data []byte) (err error) {
+	f, err := os.Create(path)
+	if err != nil {
+		return fmt.Errorf("creating %s: %w", path, err)
+	}
+	defer func() {
+		if closeErr := f.Close(); closeErr != nil && err == nil {
+			err = fmt.Errorf("closing %s: %w", path, closeErr)
+		}
+	}()
+
+	_, err = f.Write(data)
+
+	return err
+}
+```

package/rules/go/hacky/errors/custom-error-type-errors-as.md

@@ -0,0 +1,54 @@
+---
+severity: minor
+detect: ast
+ast:
+    rule:
+        kind: type_assertion_expression
+        has:
+            field: operand
+            regex: '^err$'
+---
+
+## Why
+
+A type assertion on an error only sees the outermost value, so it stops matching as soon as the error is wrapped with `%w` anywhere below. `errors.AsType` (or `errors.As`) walks the chain and returns the typed error wherever it sits. A type switch on `err.(type)` has the same weakness.
+
+## Message
+
+type assertion on err misses wrapped errors; use errors.AsType or errors.As
+
+## Bad
+
+```go
+func field(err error) string {
+	// BAD: assertion only sees the outermost error
+	if ve, ok := err.(*ValidationError); ok {
+		return ve.Field
+	}
+
+	return ""
+}
+```
+
+## Good
+
+```go
+func field(err error) string {
+	if ve, ok := errors.AsType[*ValidationError](err); ok {
+		return ve.Field
+	}
+
+	return ""
+}
+```
+
+```go
+func field(err error) string {
+	var ve *ValidationError
+	if errors.As(err, &ve) {
+		return ve.Field
+	}
+
+	return ""
+}
+```

package/rules/go/hacky/errors/ignored-error-blank.md

@@ -0,0 +1,84 @@
+---
+severity: major
+detect: ast
+ignore:
+    - "**/*_test.go"
+ast:
+    rule:
+        any:
+            - kind: short_var_declaration
+            - kind: assignment_statement
+        has:
+            field: left
+            regex: '(^|,\s*)_$'
+        all:
+            - has:
+                  field: right
+                  has:
+                      kind: call_expression
+                      not:
+                          has:
+                              field: function
+                              regex: '(\.Close|\.Load|\.LoadOrStore)$|^fmt\.Fprint|^os\.LookupEnv$'
+---
+
+## Why
+
+Assigning a returned error to the blank identifier makes the failure disappear at compile time and at runtime: the file is not removed, the number is zero, and the program keeps going with the wrong state. This is the Go form of an empty catch. Check the error and handle or return it; if it truly cannot matter, say why in a comment on the call so the next reader does not have to guess.
+
+## Message
+
+returned error discarded with the blank identifier; check it or comment why it cannot matter
+
+## Bad
+
+```go
+func cleanup(path string) {
+	// BAD: a failed removal leaves the file behind and nobody knows
+	_ = os.Remove(path)
+}
+```
+
+```go
+func parseLimit(raw string) int {
+	// BAD: bad input silently becomes zero
+	limit, _ := strconv.Atoi(raw)
+
+	return limit
+}
+```
+
+## Good
+
+```go
+func cleanup(path string) error {
+	if err := os.Remove(path); err != nil && !errors.Is(err, fs.ErrNotExist) {
+		return fmt.Errorf("removing %s: %w", path, err)
+	}
+
+	return nil
+}
+```
+
+```go
+func parseLimit(raw string) (int, error) {
+	limit, err := strconv.Atoi(raw)
+	if err != nil {
+		return 0, fmt.Errorf("parsing limit %q: %w", raw, err)
+	}
+
+	return limit, nil
+}
+```
+
+```go
+func readAll(path string) ([]byte, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, fmt.Errorf("opening %s: %w", path, err)
+	}
+	defer func() { _ = f.Close() }()
+
+	return io.ReadAll(f)
+}
+```

package/rules/go/hacky/errors/panic-only-unrecoverable.md

@@ -0,0 +1,77 @@
+---
+severity: major
+detect: ast
+ast:
+    rule:
+        kind: call_expression
+        has:
+            field: function
+            regex: '^panic$'
+        not:
+            any:
+                - inside:
+                      kind: function_declaration
+                      stopBy: end
+                      has:
+                          field: name
+                          regex: '^(main|init|Must\w*)$'
+                - inside:
+                      kind: default_case
+                      stopBy: end
+ignore:
+    - '**/*_test.go'
+---
+
+## Why
+
+A panic in library code turns an operational failure such as a missing row or a bad input into a process crash that the caller cannot handle. Panics belong to genuinely unrecoverable situations: `init` setup that cannot proceed, `Must` helpers that document the contract in their name, and impossible states after exhaustive handling. Everything else returns an error.
+
+## Message
+
+panic in library code; return an error and let the caller decide
+
+## Bad
+
+```go
+func (s *Store) Get(id string) *Item {
+	item, ok := s.items[id]
+	if !ok {
+		// BAD: a missing row is an operational error, not a violated invariant
+		panic("item not found")
+	}
+
+	return item
+}
+```
+
+## Good
+
+```go
+func (s *Store) Get(id string) (*Item, error) {
+	item, ok := s.items[id]
+	if !ok {
+		return nil, fmt.Errorf("item %s: %w", id, ErrNotFound)
+	}
+
+	return item, nil
+}
+```
+
+```go
+func init() {
+	if err := setupTransport(); err != nil {
+		panic(fmt.Sprintf("transport initialization failed: %v", err))
+	}
+}
+```
+
+```go
+func label(status Status) string {
+	switch status {
+	case StatusActive, StatusPending:
+		return string(status)
+	default:
+		panic(fmt.Sprintf("unhandled status: %v", status))
+	}
+}
+```

package/rules/go/hacky/errors/sentinel-errors-with-errors-is.md

@@ -0,0 +1,63 @@
+---
+severity: minor
+detect: ast
+ast:
+    rule:
+        kind: binary_expression
+        regex: '(==|!=)'
+        has:
+            any:
+                - kind: identifier
+                - kind: selector_expression
+            regex: '(^|\.)Err[A-Z]\w*$'
+---
+
+## Why
+
+Comparing an error with `==` only matches the exact value, so it works until someone wraps the error with `%w` one layer down, and then the branch silently stops firing. `errors.Is` walks the chain and keeps working as the code around it grows.
+
+## Message
+
+error compared with == misses wrapped errors; use errors.Is
+
+## Bad
+
+```go
+func status(err error) int {
+	// BAD: equality misses the sentinel once it has been wrapped
+	if err == ErrNotFound {
+		return http.StatusNotFound
+	}
+
+	return http.StatusInternalServerError
+}
+```
+
+```go
+func retry(err error) bool {
+	// BAD: equality misses the sentinel once it has been wrapped
+	return err != store.ErrConflict
+}
+```
+
+## Good
+
+```go
+func status(err error) int {
+	if errors.Is(err, ErrNotFound) {
+		return http.StatusNotFound
+	}
+
+	return http.StatusInternalServerError
+}
+```
+
+```go
+func load() error {
+	if err := read(); err != nil {
+		return err
+	}
+
+	return nil
+}
+```

package/rules/go/hacky/errors/wrap-errors-with-w.md

@@ -0,0 +1,71 @@
+---
+severity: major
+detect: ast
+ast:
+    rule:
+        kind: call_expression
+        all:
+            - has:
+                  field: function
+                  regex: '^fmt\.Errorf$'
+            - has:
+                  field: arguments
+                  all:
+                      - has:
+                            kind: interpreted_string_literal
+                            regex: '%[vs]'
+                            not:
+                                regex: '%w'
+                      - has:
+                            regex: '^err(\.Error\(\))?$'
+---
+
+## Why
+
+Formatting an error with `%v` or `%s` flattens it to text, so `errors.Is` and `errors.As` upstream can no longer see the sentinel or type underneath. The wrap looks identical at a glance and the breakage only appears when a caller starts matching on the cause. Use `%w` for the error argument so the chain survives.
+
+## Message
+
+fmt.Errorf with %v drops the error chain; wrap with %w
+
+## Bad
+
+```go
+func load(path string) error {
+	if err := read(path); err != nil {
+		// BAD: %v flattens err so errors.Is stops working upstream
+		return fmt.Errorf("reading %s: %v", path, err)
+	}
+
+	return nil
+}
+```
+
+```go
+func load(path string) error {
+	if err := read(path); err != nil {
+		// BAD: err.Error() flattens the chain to a string
+		return fmt.Errorf("reading %s: %s", path, err.Error())
+	}
+
+	return nil
+}
+```
+
+## Good
+
+```go
+func load(path string) error {
+	if err := read(path); err != nil {
+		return fmt.Errorf("reading %s: %w", path, err)
+	}
+
+	return nil
+}
+```
+
+```go
+func check(code int) error {
+	return fmt.Errorf("unexpected status %d", code)
+}
+```

package/rules/go/hacky/state/package-level-mutable-var.md

@@ -0,0 +1,95 @@
+---
+severity: minor
+detect: ast
+ast:
+    rule:
+        kind: var_spec
+        inside:
+            kind: var_declaration
+            stopBy: end
+        not:
+            inside:
+                any:
+                    - kind: function_declaration
+                    - kind: method_declaration
+                    - kind: func_literal
+                stopBy: end
+        any:
+            - has:
+                  kind: map_type
+            - has:
+                  kind: slice_type
+            - has:
+                  kind: expression_list
+                  has:
+                      kind: composite_literal
+                      has:
+                          any:
+                              - kind: map_type
+                              - kind: slice_type
+            - has:
+                  kind: expression_list
+                  has:
+                      kind: call_expression
+                      regex: '^make\('
+ignore:
+    - '**/*_test.go'
+---
+
+## Why
+
+A package-level map or slice is shared by every goroutine and every test in the process, with no owner to guard it. Concurrent writes race, tests leak state into each other, and nothing in a function signature says the function depends on it. Put the collection in a struct with its own mutex, construct it explicitly, and pass it to what needs it.
+
+## Message
+
+package-level mutable collection is shared global state; own it in a struct and pass it in
+
+## Bad
+
+```go
+package cache
+
+// BAD: every goroutine writes to the same unguarded map
+var entries = map[string][]byte{}
+
+func Put(key string, value []byte) {
+	entries[key] = value
+}
+```
+
+```go
+package registry
+
+// BAD: appended to from init functions across the package, in no defined order
+var handlers []Handler
+```
+
+## Good
+
+```go
+package cache
+
+type Cache struct {
+	mu      sync.RWMutex
+	entries map[string][]byte
+}
+
+func New() *Cache {
+	return &Cache{entries: make(map[string][]byte)}
+}
+
+func (c *Cache) Put(key string, value []byte) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	c.entries[key] = value
+}
+```
+
+```go
+package registry
+
+var ErrDuplicate = errors.New("handler already registered")
+
+const defaultCapacity = 16
+```

package/rules/go/hacky/structure/os-exit-only-in-main.md

@@ -0,0 +1,61 @@
+---
+severity: major
+detect: ast
+ast:
+    rule:
+        kind: call_expression
+        has:
+            field: function
+            regex: '^(os\.Exit|log\.Fatal(f|ln)?)$'
+        not:
+            inside:
+                kind: function_declaration
+                stopBy: end
+                has:
+                    field: name
+                    regex: '^main$'
+ignore:
+    - '**/*_test.go'
+---
+
+## Why
+
+`os.Exit` and the `log.Fatal` family end the process on the spot, skipping every deferred close and flush up the stack and making the function impossible to reuse or test. Return an error instead and let `main` be the one place that decides to exit.
+
+## Message
+
+os.Exit outside main skips every defer; return an error and exit from main
+
+## Bad
+
+```go
+func run() error {
+	cfg, err := loadConfig()
+	if err != nil {
+		// BAD: exits from a library-style function, skipping every defer up the stack
+		log.Fatalf("loading config: %v", err)
+	}
+
+	return serve(cfg)
+}
+```
+
+## Good
+
+```go
+func run() error {
+	cfg, err := loadConfig()
+	if err != nil {
+		return fmt.Errorf("loading config: %w", err)
+	}
+
+	return serve(cfg)
+}
+
+func main() {
+	if err := run(); err != nil {
+		slog.Error("fatal error", "error", err)
+		os.Exit(1)
+	}
+}
+```