From 131ec3de8e90618ad2b8f1da9e4eabdc1cd1e6b0 Mon Sep 17 00:00:00 2001
From: Martin Tournoij <martin@arp242.net>
Date: Wed, 16 Nov 2022 05:17:00 +0100
Subject: [PATCH] A few staticcheck fixes (#539)

This fixes a few small staticcheck issues; turns out that staticcheck
only compiles the files for the current GOOS:
https://staticcheck.io/docs/running-staticcheck/cli/build-tags/

You can run all systems with:

	staticcheck -matrix <<EOF
	windows: GOOS=windows
	linux: GOOS=linux
	freebsd: GOOS=freebsd
	openbsd: GOOS=openbsd
	netbsd: GOOS=netbsd
	darwin: GOOS=darwin
	illumos: GOOS=illumos
	EOF

The CI runner doesn't really support that, but it's little more than a
small wrapper around "go install" with some variables, so just use that
directly instead of the action.
---
 .github/workflows/staticcheck.yml | 31 +++++++++++++++++++-----
 CHANGELOG.md                      |  6 ++++-
 backend_kqueue.go                 | 39 +++++++++++++++++++------------
 backend_windows.go                |  6 +++--
 internal/freebsd.go               |  2 +-
 internal/internal.go              |  2 ++
 internal/unix.go                  |  2 +-
 7 files changed, 62 insertions(+), 26 deletions(-)
 create mode 100644 internal/internal.go

diff --git a/.github/workflows/staticcheck.yml b/.github/workflows/staticcheck.yml
index 2906aa9..f3caf4d 100644
--- a/.github/workflows/staticcheck.yml
+++ b/.github/workflows/staticcheck.yml
@@ -10,9 +10,28 @@ jobs:
     name:    'staticcheck'
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
-      with:
-        fetch-depth: 1
-    - uses: dominikh/staticcheck-action@v1.2.0
-      with:
-        version: '2022.1'
+      - id: install_go
+        uses: WillAbides/setup-go-faster@v1.7.0
+        with:
+          go-version: "1.19.x"
+
+      - uses: actions/cache@v3
+        with:
+          key: ${{ runner.os }}-staticcheck
+          path: |
+            ${{ runner.temp }}/staticcheck
+            ${{ steps.install_go.outputs.GOCACHE || '' }}
+
+      - run: |
+          export STATICCHECK_CACHE="${{ runner.temp }}/staticcheck"
+          go install honnef.co/go/tools/cmd/staticcheck@latest
+
+          $(go env GOPATH)/bin/staticcheck -matrix <<EOF
+          windows: GOOS=windows
+          linux: GOOS=linux
+          freebsd: GOOS=freebsd
+          openbsd: GOOS=openbsd
+          netbsd: GOOS=netbsd
+          darwin: GOOS=darwin
+          illumos: GOOS=illumos
+          EOF
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3b7f9e1..31fa1a4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -40,10 +40,14 @@ Unreleased
 
 - kqueue: deal with `rm -rf watched-dir` better ([#526], [#537])
 
-- Add `Watcher.Errors` and `Watcher.Events` to the no-op `Watcher` in
+- other: add `Watcher.Errors` and `Watcher.Events` to the no-op `Watcher` in
   `backend_other.go`, making it easier to use on unsupported platforms such as
   WASM, AIX, etc. ([#528])
 
+- other: use the backend_other.go no-op if the `appengine` build tag is set;
+  Google AppEngine forbids usage of the unsafe package so the inotify backend
+  won't work there.
+
 
 [#371]: https://github.com/fsnotify/fsnotify/pull/371
 [#516]: https://github.com/fsnotify/fsnotify/pull/516
diff --git a/backend_kqueue.go b/backend_kqueue.go
index b6f5121..e48225b 100644
--- a/backend_kqueue.go
+++ b/backend_kqueue.go
@@ -6,7 +6,6 @@ package fsnotify
 import (
 	"errors"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"sync"
@@ -570,8 +569,8 @@ func (w *Watcher) readEvents() {
 					}
 				} else {
 					filePath := filepath.Clean(event.Name)
-					if fileInfo, err := os.Lstat(filePath); err == nil {
-						err := w.sendFileCreatedEventIfNew(filePath, fileInfo)
+					if fi, err := os.Lstat(filePath); err == nil {
+						err := w.sendFileCreatedEventIfNew(filePath, fi)
 						if err != nil {
 							if !w.sendError(err) {
 								closed = true
@@ -610,15 +609,20 @@ func (w *Watcher) newEvent(name string, mask uint32) Event {
 // watchDirectoryFiles to mimic inotify when adding a watch on a directory
 func (w *Watcher) watchDirectoryFiles(dirPath string) error {
 	// Get all files
-	files, err := ioutil.ReadDir(dirPath)
+	files, err := os.ReadDir(dirPath)
 	if err != nil {
 		return err
 	}
 
-	for _, fileInfo := range files {
-		path := filepath.Join(dirPath, fileInfo.Name())
+	for _, f := range files {
+		path := filepath.Join(dirPath, f.Name())
 
-		cleanPath, err := w.internalWatch(path, fileInfo)
+		fi, err := f.Info()
+		if err != nil {
+			return fmt.Errorf("%q: %w", filepath.Join(dirPath, fi.Name()), err)
+		}
+
+		cleanPath, err := w.internalWatch(path, fi)
 		if err != nil {
 			// No permission to read the file; that's not a problem: just skip.
 			// But do add it to w.fileExists to prevent it from being picked up
@@ -628,7 +632,7 @@ func (w *Watcher) watchDirectoryFiles(dirPath string) error {
 			case errors.Is(err, unix.EACCES) || errors.Is(err, unix.EPERM):
 				cleanPath = filepath.Clean(path)
 			default:
-				return fmt.Errorf("%q: %w", filepath.Join(dirPath, fileInfo.Name()), err)
+				return fmt.Errorf("%q: %w", filepath.Join(dirPath, fi.Name()), err)
 			}
 		}
 
@@ -645,7 +649,7 @@ func (w *Watcher) watchDirectoryFiles(dirPath string) error {
 // This functionality is to have the BSD watcher match the inotify, which sends
 // a create event for files created in a watched directory.
 func (w *Watcher) sendDirectoryChangeEvents(dir string) error {
-	files, err := ioutil.ReadDir(dir)
+	files, err := os.ReadDir(dir)
 	if err != nil {
 		// Directory no longer exists: we can ignore this safely. kqueue will
 		// still give us the correct events.
@@ -655,8 +659,13 @@ func (w *Watcher) sendDirectoryChangeEvents(dir string) error {
 		return fmt.Errorf("fsnotify.sendDirectoryChangeEvents: %w", err)
 	}
 
-	for _, fi := range files {
-		err := w.sendFileCreatedEventIfNew(filepath.Join(dir, fi.Name()), fi)
+	for _, f := range files {
+		fi, err := f.Info()
+		if err != nil {
+			return fmt.Errorf("fsnotify.sendDirectoryChangeEvents: %w", err)
+		}
+
+		err = w.sendFileCreatedEventIfNew(filepath.Join(dir, fi.Name()), fi)
 		if err != nil {
 			// Don't need to send an error if this file isn't readable.
 			if errors.Is(err, unix.EACCES) || errors.Is(err, unix.EPERM) {
@@ -669,7 +678,7 @@ func (w *Watcher) sendDirectoryChangeEvents(dir string) error {
 }
 
 // sendFileCreatedEvent sends a create event if the file isn't already being tracked.
-func (w *Watcher) sendFileCreatedEventIfNew(filePath string, fileInfo os.FileInfo) (err error) {
+func (w *Watcher) sendFileCreatedEventIfNew(filePath string, fi os.FileInfo) (err error) {
 	w.mu.Lock()
 	_, doesExist := w.fileExists[filePath]
 	w.mu.Unlock()
@@ -680,7 +689,7 @@ func (w *Watcher) sendFileCreatedEventIfNew(filePath string, fileInfo os.FileInf
 	}
 
 	// like watchDirectoryFiles (but without doing another ReadDir)
-	filePath, err = w.internalWatch(filePath, fileInfo)
+	filePath, err = w.internalWatch(filePath, fi)
 	if err != nil {
 		return err
 	}
@@ -692,8 +701,8 @@ func (w *Watcher) sendFileCreatedEventIfNew(filePath string, fileInfo os.FileInf
 	return nil
 }
 
-func (w *Watcher) internalWatch(name string, fileInfo os.FileInfo) (string, error) {
-	if fileInfo.IsDir() {
+func (w *Watcher) internalWatch(name string, fi os.FileInfo) (string, error) {
+	if fi.IsDir() {
 		// mimic Linux providing delete events for subdirectories, but preserve
 		// the flags used if currently watching subdirectory
 		w.mu.Lock()
diff --git a/backend_windows.go b/backend_windows.go
index e99139e..86a320a 100644
--- a/backend_windows.go
+++ b/backend_windows.go
@@ -635,6 +635,8 @@ func (w *Watcher) readEvents() {
 		}
 
 		switch qErr {
+		case nil:
+			// No error
 		case windows.ERROR_MORE_DATA:
 			if watch == nil {
 				w.sendError(errors.New("ERROR_MORE_DATA has unexpectedly null lpOverlapped buffer"))
@@ -656,7 +658,6 @@ func (w *Watcher) readEvents() {
 		default:
 			w.sendError(os.NewSyscallError("GetQueuedCompletionPort", qErr))
 			continue
-		case nil:
 		}
 
 		var offset uint32
@@ -733,8 +734,9 @@ func (w *Watcher) readEvents() {
 
 			// Error!
 			if offset >= n {
+				//lint:ignore ST1005 Windows should be capitalized
 				w.sendError(errors.New(
-					"Windows system assumed buffer larger than it is, events have likely been missed."))
+					"Windows system assumed buffer larger than it is, events have likely been missed"))
 				break
 			}
 		}
diff --git a/internal/freebsd.go b/internal/freebsd.go
index 4128482..285c54b 100644
--- a/internal/freebsd.go
+++ b/internal/freebsd.go
@@ -16,8 +16,8 @@ var (
 
 var maxfiles uint64
 
-// Go 1.19 will do this automatically: https://go-review.googlesource.com/c/go/+/393354/
 func SetRlimit() {
+	// Go 1.19 will do this automatically: https://go-review.googlesource.com/c/go/+/393354/
 	var l syscall.Rlimit
 	err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &l)
 	if err == nil && l.Cur != l.Max {
diff --git a/internal/internal.go b/internal/internal.go
new file mode 100644
index 0000000..7daa45e
--- /dev/null
+++ b/internal/internal.go
@@ -0,0 +1,2 @@
+// Package internal contains some helpers.
+package internal
diff --git a/internal/unix.go b/internal/unix.go
index 301b242..e006de4 100644
--- a/internal/unix.go
+++ b/internal/unix.go
@@ -16,8 +16,8 @@ var (
 
 var maxfiles uint64
 
-// Go 1.19 will do this automatically: https://go-review.googlesource.com/c/go/+/393354/
 func SetRlimit() {
+	// Go 1.19 will do this automatically: https://go-review.googlesource.com/c/go/+/393354/
 	var l syscall.Rlimit
 	err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &l)
 	if err == nil && l.Cur != l.Max {
-- 
2.50.1