Cosmetic changes to linters

Author: mdulin2

.golangci.yml

@@ -26,6 +26,7 @@ linters:
     - gosec
     - govet
     - ineffassign
+    - iotamixing
     - loggercheck
     # Check for simple misspellings of words. 
     - mnd
@@ -211,9 +212,14 @@ linters:
       channelcheck:
         type: "module" 
         description: Static analysis for go channel issues   
-        settings: 
+        settings:
           CheckBlockingSends: true
           CheckUnbufferedChannels: false
+          CheckEmptyDefault: true
+          # msgC sends are intentionally blocking (watcher backpressure, not dropping).
+          IgnoreChannelsByName:
+            - msgC
+            - msgChan
   exclusions:
     generated: lax
     presets:

linters/Makefile

@@ -16,7 +16,8 @@ install-golangci-lint:
 	  github.com/golangci/golangci-lint/v2/cmd/golangci-lint@$(GOLANGCI_LINT_VERSION)
 
 # Custom golangci-lint with our module plugins baked in. Driven by
-# .custom-gcl.yml at the repo root; output goes to ./bin per `destination:`.
+# .custom-gcl.yml in this directory (golangci-lint custom reads it from the
+# cwd); output goes to ./bin per `destination:`.
 build-golangci-lint: install-golangci-lint
 	$(BIN_DIR)/golangci-lint custom
 

linters/README.md

@@ -10,7 +10,7 @@ Currently supported linters:
 
 | Name           | Purpose                                                  | Features                                                                                                                  |
 | -------------- | -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
-| `channelcheck` | Flag channel usage patterns that can deadlock or block.  | • Blocking channel sends outside a `select`<br>• Unbuffered channel creation (`make(chan T)`)<br>• Ignore specific channels |
+| `channelcheck` | Flag channel usage patterns that can deadlock or block.  | • Blocking channel sends outside a `select`<br>• Unbuffered channel creation (`make(chan T)`)<br>• Empty `default:` that silently drops a send (advisory, off by default)<br>• Ignore specific channels |
 
 
 ## Build & test
@@ -58,9 +58,20 @@ linters:
           blocking: true
           unbuffered: false
           bufferMax: 0
+          emptyDefault: false
           ignoreChannelsByName: [errC]
 ```
 
+`channelcheck` settings:
+
+| Setting                | Type       | Default | Description                                                                                                                              |
+| ---------------------- | ---------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `blocking`             | `bool`     | `true`  | Flag blocking sends that have no escape (timer, `default:`, or `ctx.Done()`), including sends outside any `select`.                       |
+| `unbuffered`           | `bool`     | `false` | Flag unbuffered channel creation (`make(chan T)` / `make(chan T, 0)`).                                                                    |
+| `bufferMax`            | `uint`     | `0`     | Flag channel buffers larger than this. `0` disables the check.                                                                            |
+| `emptyDefault`         | `bool`     | `false` | Advisory: flag an empty `default:` in a `select` with a send, since it silently drops the send. Off by default — it fires on the idiomatic non-blocking/coalescing-send pattern, so enable it only where dropping should always be logged or documented. |
+| `ignoreChannelsByName` | `[]string` | `[]`    | Channel/field names whose direct sends are exempt from the blocking-send, empty-default, and `ctx.Done()` checks.                        |
+
 ## Development
 
 ### Adding a new linter
@@ -94,6 +105,8 @@ linters:
        path: ./rules/<linter>
    ```
 6. `make test && make build && make build-golangci-lint` to verify.
+7. Add linter to `.golangci.yml`.
+8. Fix linter errors in the monorepo with legitimate changes or a `nolint` comment.
 
 ### Layout
 

linters/rules/channelcheck/channelcheck.go

@@ -4,13 +4,6 @@ package channelcheck
 	Strategy: Identify proper SendStmt's early. If we don't see it within a Select, then it's not being used correctly.
 	 Or, we simply MISS it, making it a false positive which is fine. We'd rather fail open and get the user to
 	 use nolints than miss a potential bug altogether.
-
-	Steps for blocking channel send:
-	- Find a SelectStmt
-	- Check if Comm Clause:
-		- See if it has a 'ast.SendStmt'.
-		- If it does, then check 'default' or 'ticker' types there too.
-	- If we find SelectStmt otherwise, it must be non-blocking and we want to flag it.
 */
 import (
 	"bytes"
@@ -26,15 +19,18 @@ import (
 	"golang.org/x/tools/go/analysis"
 )
 
-type ChannelCheckPlugin struct {
-	settings Settings
-}
+// ChannelCheckPlugin is the golangci-lint module-plugin entry point. Its
+// configuration lives in the package-level settings var (populated by New),
+// which is the single source of truth — shared with the standalone
+// cmd/wormhole-lint multichecker, which populates the same var via flags.
+type ChannelCheckPlugin struct{}
 
 // Settings holds the configuration for the channelcheck linter.
 type Settings struct {
 	CheckUnbufferedChannels bool     // Enable/disable checking for unbuffered channel creation.
 	CheckBufferAmount       uint64   // The amount that can be in a buffer. 0 means don't do this check.
 	CheckBlockingSends      bool     // Enable/disable checking for blocking sends without default/timeout.
+	CheckEmptyDefault       bool     // Enable/disable the (advisory) empty-default-drops-the-send check.
 	IgnoreChannelsByName    []string // Channel/field names whose direct sends are exempt from the blocking-send check.
 
 	// ignoreChannelNames is the lookup form of IgnoreChannelsByName, built
@@ -81,13 +77,12 @@ func New(settingsNew any) (register.LinterPlugin, error) {
 	if err != nil {
 		return nil, err
 	}
-	settings.CheckBlockingSends = s.CheckBlockingSends
-	settings.CheckBufferAmount = s.CheckBufferAmount
-	settings.CheckUnbufferedChannels = s.CheckUnbufferedChannels
-	settings.IgnoreChannelsByName = s.IgnoreChannelsByName
+	// Assign the whole struct so a future Settings field can't be silently
+	// dropped, then derive the lookup map from the decoded slice.
+	settings = s
 	settings.ignoreChannelNames = buildIgnoreSet(s.IgnoreChannelsByName)
 
-	return &ChannelCheckPlugin{settings: s}, nil
+	return &ChannelCheckPlugin{}, nil
 }
 
 func buildIgnoreSet(names []string) map[string]bool {
@@ -102,21 +97,17 @@ func buildIgnoreSet(names []string) map[string]bool {
 }
 
 func (f *ChannelCheckPlugin) BuildAnalyzers() ([]*analysis.Analyzer, error) {
-	return []*analysis.Analyzer{
-		{
-			Name:  "channelcheck",
-			Doc:   "reports channel blocking issues",
-			Run:   run,
-			Flags: flagSet,
-		},
-	}, nil
+	// Reuse the package-level Analyzer (the same one the standalone
+	// cmd/wormhole-lint multichecker runs) instead of defining a second one.
+	return []*analysis.Analyzer{Analyzer}, nil
 }
 
 // Initialize the flags from the golangci-lint
 func init() {
 
 	flagSet.BoolVar(&settings.CheckUnbufferedChannels, "unbuffered", false, "Check for unbuffered channel creation")
 	flagSet.BoolVar(&settings.CheckBlockingSends, "blocking", true, "Check for blocking sends without default/timeout")
+	flagSet.BoolVar(&settings.CheckEmptyDefault, "emptyDefault", false, "Advise when an empty default case silently drops a send")
 	flagSet.Uint64Var(&settings.CheckBufferAmount, "bufferMax", 0, "Check for maximum length of channel buffer being exceeded")
 	Analyzer.Flags = flagSet
 	register.Plugin("channelcheck", New)
@@ -189,10 +180,10 @@ func run(pass *analysis.Pass) (interface{}, error) {
 				// in the select (a receive-only select with an empty default has no
 				// backpressure concern). Anchor at each tracked send so users can
 				// suppress with a //nolint next to the blocking send.
-				if selectAnalysis.EmptyDefaultPos != token.NoPos {
+				if settings.CheckEmptyDefault && selectAnalysis.EmptyDefaultPos != token.NoPos {
 					for _, send := range trackedSends {
 						pass.Reportf(send.Pos(),
-							"empty default case in channel select. Please add logging to it on failure")
+							"empty default in channel select silently drops the send; log it or document why dropping is intended")
 					}
 				}
 

linters/rules/channelcheck/channelcheck_test.go

@@ -20,6 +20,7 @@ func runFixture(t *testing.T, pkg string, override Settings) {
 
 	settings.CheckUnbufferedChannels = override.CheckUnbufferedChannels
 	settings.CheckBlockingSends = override.CheckBlockingSends
+	settings.CheckEmptyDefault = override.CheckEmptyDefault
 	settings.CheckBufferAmount = override.CheckBufferAmount
 	settings.IgnoreChannelsByName = override.IgnoreChannelsByName
 	settings.ignoreChannelNames = buildIgnoreSet(override.IgnoreChannelsByName)
@@ -36,7 +37,7 @@ func TestBlockingSend(t *testing.T) {
 }
 
 func TestEmptyDefault(t *testing.T) {
-	runFixture(t, "empty_default", defaultSettings())
+	runFixture(t, "empty_default", Settings{CheckBlockingSends: true, CheckEmptyDefault: true})
 }
 
 func TestCtxDoneOnly(t *testing.T) {

linters/rules/channelcheck/testdata/src/empty_default/empty_default.go

@@ -4,7 +4,7 @@ package fixture
 func emptyDefault() {
 	c := make(chan int, 1)
 	select {
-	case c <- 1: // want `empty default case`
+	case c <- 1: // want `empty default in channel select silently drops the send`
 	default:
 	}
 }

scripts/lint.sh

@@ -68,10 +68,12 @@ format(){
 # Content hash of the linters/ source, used to decide whether a rebuild is needed.
 # Hashes every file under linters/ (regardless of git tracking) except the
 # bin/ and build/ build outputs, so any source edit triggers exactly one rebuild.
+# Runs find from inside LINTERS_DIR so paths are relative: sha256sum embeds the
+# path, so an absolute one would make the hash checkout-path dependent.
 linters_source_hash() {
-    find "$LINTERS_DIR" -type f \
+    ( cd "$LINTERS_DIR" && find . -type f \
         -not -path '*/bin/*' -not -path '*/build/*' \
-        -print0 | sort -z | xargs -0 sha256sum | sha256sum | cut -d' ' -f1
+        -print0 | sort -z | xargs -0 sha256sum | sha256sum | cut -d' ' -f1 )
 }
 
 ensure_wormhole_golangci_lint() {