Fix various lint warnings and suggestions

diff --git a/buildlog.go b/buildlog.go
index bd1a173f02c364c5981a349685278abdba284d4d..09d6cb211e6ad09a6ca071fc6b1930c41d3bb707 100644 (file)
--- a/buildlog.go
+++ b/buildlog.go
@@ -37,9 +37,9 @@ const HumanTimeFmt = "2006-01-02 15:04:05.000000000 Z07:00"
 
 type BuildLogJob struct {
        tgt      *Tgt
+       rec      map[string][]string
        started  time.Time
        exitCode int
-       rec      map[string][]string
 }
 
 type ByStarted []*BuildLogJob
@@ -200,7 +200,8 @@ func showBuildLog(tgt *Tgt, buildLogRec map[string][]string, depth int) error {
                if dep.rel == tgt.rel {
                        continue
                }
-               rec, err := parseBuildLogRec(dep)
+               var rec map[string][]string
+               rec, err = parseBuildLogRec(dep)
                if err != nil {
                        if errors.Is(err, fs.ErrNotExist) {
                                continue
@@ -210,7 +211,8 @@ func showBuildLog(tgt *Tgt, buildLogRec map[string][]string, depth int) error {
                if rec["Build"][0] != buildLogRec["Build"][0] {
                        continue
                }
-               started, err := tai64n.Decode(rec["Started"][0])
+               var started time.Time
+               started, err = tai64n.Decode(rec["Started"][0])
                if err != nil {
                        return ErrLine(err)
                }

diff --git a/dep.go b/dep.go
index 77c248ec9026c6ca1e325c11468e643c030654ed..8fe4fffd5fd6c682cb4ec70782f7ad1f44ae2227 100644 (file)
--- a/dep.go
+++ b/dep.go
@@ -78,14 +78,14 @@ func (ifchange *Ifchange) Hash() Hash {
 }
 
 type Dep struct {
-       build     uuid.UUID
-       always    bool
        stamp     Hash
        ifcreates []*Tgt
        ifchanges []*Ifchange
+       build     uuid.UUID
+       always    bool
 }
 
-func ifcreate(w io.Writer, fdDepName string, tgt string) (err error) {
+func ifcreate(w io.Writer, fdDepName, tgt string) (err error) {
        tracef(CDebug, "ifcreate: %s <- %s", fdDepName, tgt)
        _, err = io.Copy(w, bytes.NewBuffer(chunkWrite(append(
                []byte{DepTypeIfcreate}, []byte(tgt)...,
@@ -203,7 +203,7 @@ func depHeadParse(data []byte) (build uuid.UUID, tail []byte, err error) {
        return
 }
 
-func chunkRead(data []byte) (typ byte, chunk []byte, tail []byte, err error) {
+func chunkRead(data []byte) (typ byte, chunk, tail []byte, err error) {
        if len(data) < 2 {
                err = errors.New("no length")
                return

diff --git a/depfix.go b/depfix.go
index 08362ab54e7c93ffeadae46783d03a02450c6f1b..bbe2ae81271c8add23bf26ec7319da2bb7417165 100644 (file)
--- a/depfix.go
+++ b/depfix.go
@@ -50,7 +50,8 @@ func depFix(root string) error {
        }
        defer dir.Close()
        for {
-               entries, err := dir.ReadDir(1 << 10)
+               var entries []fs.DirEntry
+               entries, err = dir.ReadDir(1 << 10)
                if err != nil {
                        if err == io.EOF {
                                break
@@ -93,11 +94,13 @@ func depFix(root string) error {
                        }
                        tracef(CDebug, "depfix: checking %s/%s", root, entry.Name())
                        fdDepPath := path.Join(redoDir, entry.Name())
-                       data, err := os.ReadFile(fdDepPath)
+                       var data []byte
+                       data, err = os.ReadFile(fdDepPath)
                        if err != nil {
                                return ErrLine(err)
                        }
-                       fdDep, err := tempfile(redoDir, entry.Name())
+                       var fdDep *os.File
+                       fdDep, err = tempfile(redoDir, entry.Name())
                        if err != nil {
                                return ErrLine(err)
                        }
@@ -112,7 +115,8 @@ func depFix(root string) error {
                                if _, err = depParse(NewTgt(""), data); err != nil {
                                        return ErrLine(err)
                                }
-                               build, data, err := depHeadParse(data)
+                               var build uuid.UUID
+                               build, data, err = depHeadParse(data)
                                if err != nil {
                                        return ErrLine(err)
                                }
@@ -187,7 +191,8 @@ func depFix(root string) error {
                                defer os.Remove(fdDepPath)
                                fdDepPath = fdDepPath[:len(fdDepPath)-4] + DepSuffix
                                r := recfile.NewReader(bytes.NewReader(data))
-                               m, err := r.NextMap()
+                               var m map[string]string
+                               m, err = r.NextMap()
                                if err != nil {
                                        return err
                                }
@@ -200,7 +205,7 @@ func depFix(root string) error {
                                        return ErrLine(err)
                                }
                                for {
-                                       m, err := r.NextMap()
+                                       m, err = r.NextMap()
                                        if err != nil {
                                                if errors.Is(err, io.EOF) {
                                                        break

diff --git a/err.go b/err.go
index b49bb536cf8579d9c787634370a2300678235d43..a6779bf167f46fb7ece8b835e4fd8e2db9c4a47f 100644 (file)
--- a/err.go
+++ b/err.go
@@ -24,8 +24,8 @@ import (
 type ErrLineErr struct {
        err      error
        file     string
-       line     int
        function string
+       line     int
 }
 
 func (err ErrLineErr) Error() string {
@@ -50,5 +50,10 @@ func ErrLine(err error) error {
                errLine.function = frame.Function + "," + errLine.function
                return errLine
        }
-       return ErrLineErr{err, frame.File, frame.Line, frame.Function}
+       return ErrLineErr{
+               err:      err,
+               file:     frame.File,
+               line:     frame.Line,
+               function: frame.Function,
+       }
 }

diff --git a/ifchange.go b/ifchange.go
index 5c294013f7bf270e7dc89a5c50db0586e3213492..46432b042446667828a1613492ac011809e2e935 100644 (file)
--- a/ifchange.go
+++ b/ifchange.go
@@ -205,7 +205,7 @@ func ifchange(tgts []*Tgt, forced, traced bool) (bool, error) {
                close(okChecker)
        }()
        for _, tgt := range tgts {
-               if _, ok := seen[tgt.rel]; ok {
+               if _, exists := seen[tgt.rel]; exists {
                        tracef(CDebug, "%s was already build as a dependant", tgt)
                        continue
                }

diff --git a/main.go b/main.go
index 1bd1b50461f93f7893ce09f2a227335c384f6d02..3597115f76b2ac19bf358a462cb64848ca5f04df 100644 (file)
--- a/main.go
+++ b/main.go
@@ -255,7 +255,8 @@ func main() {
                if _, err = fd.Seek(0, io.SeekStart); err != nil {
                        log.Fatal(err)
                }
-               tgtsRaw, err := io.ReadAll(bufio.NewReader(fd))
+               var tgtsRaw []byte
+               tgtsRaw, err = io.ReadAll(bufio.NewReader(fd))
                if err != nil {
                        log.Fatal(err)
                }

diff --git a/ood.go b/ood.go
index 120a7de8afd554d95cb8397c01182a4db6eac99e..3cf50d82538418a637fdf896464e7a80027b9f4a 100644 (file)
--- a/ood.go
+++ b/ood.go
@@ -112,9 +112,7 @@ func isOOD(tgt *Tgt, level int, seen map[string]*Tgt) (bool, error) {
                                OODCache[tgt.rel] = ood
                                return ood, nil
                        }
-                       if err != nil {
-                               return true, TgtError{tgt, ErrLine(err)}
-                       }
+                       return true, TgtError{tgt, ErrLine(err)}
                }
                DepCache[tgt.rel] = dep
        }
@@ -170,11 +168,13 @@ func isOOD(tgt *Tgt, level int, seen map[string]*Tgt) (bool, error) {
                        tracef(CDebug, "ood: %s%s -> %s: same inode", indent, tgt, ifchange.tgt)
                } else {
                        tracef(CDebug, "ood: %s%s -> %s: inode differs", indent, tgt, ifchange.tgt)
-                       fd, err := os.Open(ifchange.tgt.a)
+                       var fd *os.File
+                       fd, err = os.Open(ifchange.tgt.a)
                        if err != nil {
                                return ood, TgtError{tgt, ErrLine(err)}
                        }
-                       hsh, err := fileHash(fd)
+                       var hsh Hash
+                       hsh, err = fileHash(fd)
                        fd.Close()
                        if err != nil {
                                return ood, TgtError{tgt, ErrLine(err)}
@@ -198,7 +198,7 @@ func isOOD(tgt *Tgt, level int, seen map[string]*Tgt) (bool, error) {
                        continue
                }
 
-               if _, ok := seen[ifchange.tgt.rel]; ok {
+               if _, exists := seen[ifchange.tgt.rel]; exists {
                        tracef(CDebug, "ood: %s%s -> %s: was always built", indent, tgt, ifchange.tgt)
                        OODCache[ifchange.tgt.rel] = false
                        continue
@@ -248,7 +248,7 @@ RecordOODTgt:
        if _, err = FdOODTgts.Seek(0, io.SeekEnd); err != nil {
                log.Fatal(err)
        }
-       if _, err := FdOODTgts.WriteString(tgt.a + "\x00"); err != nil {
+       if _, err = FdOODTgts.WriteString(tgt.a + "\x00"); err != nil {
                log.Fatal(err)
        }
        flock.Type = unix.F_UNLCK

diff --git a/run.go b/run.go
index ccf562db4e2fa9357d463aef6832a5820689dabd..4921548a2db3998bad2a16ff966e450c29a03e6b 100644 (file)
--- a/run.go
+++ b/run.go
@@ -36,6 +36,7 @@ import (
        "syscall"
        "time"
 
+       "github.com/google/uuid"
        "go.cypherpunks.su/recfile/v2"
        "go.cypherpunks.su/tai64n/v3"
        "golang.org/x/sys/unix"
@@ -99,11 +100,11 @@ func init() {
 }
 
 type RunError struct {
+       Err      error
        Tgt      *Tgt
-       DoFile   string
        Started  *time.Time
        Finished *time.Time
-       Err      error
+       DoFile   string
 }
 
 func (e *RunError) Name() string {
@@ -127,7 +128,7 @@ func mkdirs(pth string) error {
        if FileExists(pth) {
                return nil
        }
-       return os.MkdirAll(pth, os.FileMode(0777))
+       return os.MkdirAll(pth, os.FileMode(0o777))
 }
 
 func isModified(dep *Dep, tgt *Tgt) (
@@ -186,7 +187,7 @@ func runScript(tgt *Tgt, errs chan error, forced, traced bool) error {
        fdLock, err := os.OpenFile(
                path.Join(redoDir, tgtT+LockSuffix),
                os.O_WRONLY|os.O_TRUNC|os.O_CREATE,
-               os.FileMode(0666),
+               os.FileMode(0o666),
        )
        if err != nil {
                return TgtError{tgt, ErrLine(err)}
@@ -198,7 +199,7 @@ func runScript(tgt *Tgt, errs chan error, forced, traced bool) error {
        lockRelease := func() {
                tracef(CLock, "LOCK_UN: %s", fdLock.Name())
                flock.Type = unix.F_UNLCK
-               if err := unix.FcntlFlock(fdLock.Fd(), unix.F_SETLK, &flock); err != nil {
+               if err = unix.FcntlFlock(fdLock.Fd(), unix.F_SETLK, &flock); err != nil {
                        log.Fatalln(err, fdLock.Name())
                }
                fdLock.Close()
@@ -225,7 +226,7 @@ func runScript(tgt *Tgt, errs chan error, forced, traced bool) error {
                        defer Jobs.Done()
                        tracef(CLock, "LOCK_EX: %s", fdLock.Name())
                LockAgain:
-                       if err := unix.FcntlFlock(fdLock.Fd(), unix.F_SETLKW, &flock); err != nil {
+                       if err = unix.FcntlFlock(fdLock.Fd(), unix.F_SETLKW, &flock); err != nil {
                                if errors.Is(err, unix.EDEADLK) {
                                        time.Sleep(10 * time.Millisecond)
                                        goto LockAgain
@@ -239,7 +240,8 @@ func runScript(tgt *Tgt, errs chan error, forced, traced bool) error {
                                        log.Fatal(err)
                                }
                        }
-                       build, err := depBuildRead(tgt.dep)
+                       var build uuid.UUID
+                       build, err = depBuildRead(tgt.dep)
                        if err == nil {
                                if build != BuildUUID {
                                        err = errors.New("was not built: build differs")
@@ -328,7 +330,9 @@ func runScript(tgt *Tgt, errs chan error, forced, traced bool) error {
        runErr := RunError{Tgt: tgt}
        // Determine basename and DIRPREFIX
        {
-               doFileRelPath, upLevels, err := findDo(fdDepW, fdDep.Name(), tgtH, tgtT)
+               var doFileRelPath string
+               var upLevels int
+               doFileRelPath, upLevels, err = findDo(fdDepW, fdDep.Name(), tgtH, tgtT)
                if err != nil {
                        cleanup()
                        return TgtError{tgt, ErrLine(err)}
@@ -441,7 +445,7 @@ func runScript(tgt *Tgt, errs chan error, forced, traced bool) error {
                fdStderr, err = os.OpenFile(
                        path.Join(redoDir, tgtT+LogSuffix),
                        os.O_WRONLY|os.O_CREATE|os.O_TRUNC,
-                       os.FileMode(0666),
+                       os.FileMode(0o666),
                )
                if err != nil {
                        cleanup()
@@ -480,7 +484,7 @@ func runScript(tgt *Tgt, errs chan error, forced, traced bool) error {
                var exitErr *exec.ExitError
                started := time.Now()
                runErr.Started = &started
-               fdStdout, err = os.OpenFile(fdStdout.Name(), os.O_RDWR, os.FileMode(0666))
+               fdStdout, err = os.OpenFile(fdStdout.Name(), os.O_RDWR, os.FileMode(0o666))
                if err != nil {
                        if fdStderr != nil {
                                fdStderr.Close()
@@ -490,7 +494,7 @@ func runScript(tgt *Tgt, errs chan error, forced, traced bool) error {
                        return
                }
                cmd.Stdout = fdStdout
-               fdDep, err = os.OpenFile(fdDep.Name(), os.O_WRONLY|os.O_APPEND, os.FileMode(0666))
+               fdDep, err = os.OpenFile(fdDep.Name(), os.O_WRONLY|os.O_APPEND, os.FileMode(0o666))
                if err != nil {
                        if fdStderr != nil {
                                fdStderr.Close()
@@ -518,7 +522,7 @@ func runScript(tgt *Tgt, errs chan error, forced, traced bool) error {
                                if fdStderr, err = os.OpenFile(
                                        logRecPath,
                                        os.O_WRONLY|os.O_CREATE|os.O_TRUNC,
-                                       os.FileMode(0666),
+                                       os.FileMode(0o666),
                                ); err == nil {
                                        fields := []recfile.Field{
                                                {Name: "Build", Value: BuildUUID.String()},
@@ -670,7 +674,7 @@ func runScript(tgt *Tgt, errs chan error, forced, traced bool) error {
                }
 
                // Was $1 touched?
-               if inode, err := inodeFromFileByPath(tgt.a); err == nil {
+               if inode, errInode := inodeFromFileByPath(tgt.a); errInode == nil {
                        if inodePrev == nil {
                                runErr.Err = Err1WasTouched
                                errs <- runErr

diff --git a/targets.go b/targets.go
index bd1fac3d383cefc1c412e19c2efd5d17b575e1da..de4821d16e24a72ea4ac2c6b0055d5a651f06506 100644 (file)
--- a/targets.go
+++ b/targets.go
@@ -17,6 +17,7 @@ package main
 
 import (
        "io"
+       "io/fs"
        "os"
        "path"
        "strings"
@@ -42,11 +43,13 @@ func targetsCollect(root string, tgts map[string]struct{}) error {
                        }
                        pth := path.Join(root, entry.Name())
                        if entry.Name() == RedoDir {
-                               redoDir, err := os.Open(pth)
+                               var redoDir *os.File
+                               redoDir, err = os.Open(pth)
                                if err != nil {
                                        return ErrLine(err)
                                }
-                               redoEntries, err := redoDir.ReadDir(0)
+                               var redoEntries []fs.DirEntry
+                               redoEntries, err = redoDir.ReadDir(0)
                                redoDir.Close()
                                if err != nil {
                                        return ErrLine(err)

diff --git a/tmp.go b/tmp.go
index d2cdb01e610b37a33018b0484fba1075337b881f..a29dc829e13d0cdb1de2d9a8f68fd33ac52df3aa 100644 (file)
--- a/tmp.go
+++ b/tmp.go
@@ -26,7 +26,7 @@ func tempfile(dir, prefix string) (*os.File, error) {
        if err != nil {
                return nil, err
        }
-       err = os.Chmod(tmp.Name(), os.FileMode(0666&^UmaskCur))
+       err = os.Chmod(tmp.Name(), os.FileMode(0o666&^UmaskCur))
        if err != nil {
                tmp.Close()
                return nil, err