esimonov / ifshort Goto Github PK

package main

type test struct {
}

func (t test) Test() test {
	return t
}

func main() {
	_ = test{}.
		Test().Test().Test().Test().Test().Test().Test().Test().Test().Test().
		Test().Test().Test().Test().Test().Test().Test().Test().Test().Test().
		Test().Test().Test().Test().Test().Test().Test().Test().Test().Test().
		Test().Test()
}

golangci-lint run --disable-all -E ifshort
ERRO Timeout exceeded: try increasing it by passing --timeout option

type Query struct {
	LastUpdatedAt time.Time
}

func (q Query) appendToSQL(sqlBuilder *strings.Builder, sqlParams []interface{}) []interface{} {
	zero := time.Time{}
	if q.LastUpdatedAt != zero {
	      
	}

	return sqlParams
}

type Query struct {
	LastUpdatedAt time.Time
}

func (q Query) appendToSQL(sqlBuilder *strings.Builder, sqlParams []interface{}) []interface{} {
	
	if zero := time.Time{}; q.LastUpdatedAt != zero {
	      
	}

	return sqlParams
}

transaction/query.go:36:10: syntax error: cannot use zero := time.Time as value
transaction/query.go:37:3: syntax error: unexpected if, expecting expression
transaction/query.go:45:2: syntax error: non-declaration statement outside function body

❯ go version
go version go1.17.6 linux/amd64

❯ golangci-lint --version
golangci-lint has version 1.44.0 built from 617470fa on 2022-01-25T11:31:17Z

lmd/listener.go:208:2: variable 'wg' is only used in the if-statement (lmd/listener.go:222:2); consider using short syntax (ifshort)
        wg := &sync.WaitGroup{}

func SendCommands(commandsByPeer map[string][]string) (code int, msg string) {
	code = 200
	msg = "OK"
	resultChan := make(chan error, len(commandsByPeer))
	wg := &sync.WaitGroup{}
	for pID := range commandsByPeer {
		PeerMapLock.RLock()
		p := PeerMap[pID]
		PeerMapLock.RUnlock()
		wg.Add(1)
		go func(peer *Peer) {
			defer logPanicExitPeer(peer)
			defer wg.Done()
			resultChan <- peer.SendCommandsWithRetry(commandsByPeer[peer.ID])
		}(p)
	}

	if waitTimeout(wg, PeerCommandTimeout) {
		code = 202
		msg = "sending command timed out but will continue in background"
		return
	}
...
}

package main

func main() {
    _ = bug(value("nil"))
}

type value string

func (m value) String() string {
    return string(m)
}

type myType struct {
    value *string
}

func bug(v value) *myType {
    testVar := v.String()
    if testVar == "nil" {
        return nil
    }

    return &myType{value: &testVar}
}

package test

import "fmt"

func test() {
        p := map[string]int{}
        q := "bar"                                                                                                                                                   

        if _, ok := p[q]; ok {
                fmt.Println(q)
        }
}

variable 'q' is only used in the if-statement (test.go:9:2); consider using short syntax (ifshort)

$ ifshort main.go
/tmp/main.go:4:2: variable 'foo' is only used in the if-statement (/tmp/main.go:14:2); consider using short syntax

internal/rbd/rbd_util.go:1619:2: variable 'removeOldKey' is only used in the if-statement (internal/rbd/rbd_util.go:1639:2); consider using short syntax (ifshort)
	removeOldKey := false
	^

golangci-lint run main.go
main.go:6:2: variable 'flag' is only used in the if-statement (main.go:16:2); consider using short syntax (ifshort)
        flag := false
        ^

internal/parallelwork/parallel_work_queue.go:127:2: variable 'cb' is only used in the if-statement (internal/parallelwork/parallel_work_queue.go:128:2); consider using short syntax (ifshort)
	cb := v.ProgressCallback
	^

func (v *Queue) maybeReportProgress(ctx context.Context) {
	cb := v.ProgressCallback
	if cb == nil {
		return
	}

	if clock.Now().Before(v.nextReportTime) {
		return
	}

	v.nextReportTime = clock.Now().Add(1 * time.Second)

	cb(ctx, v.enqueuedWork, v.activeWorkerCount, v.completedWork)
}

fs/entry.go:141:2: variable 'name' is only used in the if-statement (fs/entry.go:151:2); consider using short syntax (ifshort)
	name := newEntry.Name()

func (e Entries) Update(newEntry Entry) Entries {
	name := newEntry.Name()
	pos := sort.Search(len(e), func(i int) bool {
		return e[i].Name() >= name
	})

	// append at the end
	if pos >= len(e) {
		return append(append(Entries(nil), e...), newEntry)
	}

	if e[pos].Name() == name {
		if pos > 0 {
			return append(append(append(Entries(nil), e[0:pos]...), newEntry), e[pos+1:]...)
		}

		return append(append(Entries(nil), newEntry), e[pos+1:]...)
	}

	if pos > 0 {
		return append(append(append(Entries(nil), e[0:pos]...), newEntry), e[pos:]...)
	}

	return append(append(Entries(nil), newEntry), e[pos:]...)
}

tests/testenv/cli_test_env.go:73:2: variable 'exe' is only used in the if-statement (tests/testenv/cli_test_env.go:74:2); consider using short syntax (ifshort)
	exe := os.Getenv("KOPIA_EXE")

// NewCLITest creates a new instance of *CLITest.
func NewCLITest(t *testing.T) *CLITest {
	t.Helper()

	exe := os.Getenv("KOPIA_EXE")
	if exe == "" {
		// exe = "kopia"
		t.Skip()
	}

        /* a bunch of lines removed */

	return &CLITest{
		startTime:                    clock.Now(),
		RepoDir:                      testutil.TempDirectory(t),
		ConfigDir:                    configDir,
		Exe:                          filepath.FromSlash(exe),
		fixedArgs:                    fixedArgs,
		DefaultRepositoryCreateFlags: formatFlags,
		LogsDir:                      logsDir,
		Environment: []string{
			"KOPIA_PASSWORD=" + TestRepoPassword,
			"KOPIA_ADVANCED_COMMANDS=enabled",
		},
	}
}

cli/command_diff.go:35:5: variable 'isDir1' is only used in the if-statement (cli/command_diff.go:38:2); consider using short syntax (ifshort)
	_, isDir1 := ent1.(fs.Directory)
	   ^
cli/command_diff.go:36:5: variable 'isDir2' is only used in the if-statement (cli/command_diff.go:38:2); consider using short syntax (ifshort)
	_, isDir2 := ent2.(fs.Directory)
	   ^

func runDiffCommand(ctx context.Context, rep repo.Repository) error {
	ent1, err := snapshotfs.FilesystemEntryFromIDWithPath(ctx, rep, *diffFirstObjectPath, false)
	if err != nil {
		return errors.Wrapf(err, "error getting filesystem entry for %v", *diffFirstObjectPath)
	}

	ent2, err := snapshotfs.FilesystemEntryFromIDWithPath(ctx, rep, *diffSecondObjectPath, false)
	if err != nil {
		return errors.Wrapf(err, "error getting filesystem entry for %v", *diffSecondObjectPath)
	}

	_, isDir1 := ent1.(fs.Directory)
	_, isDir2 := ent2.(fs.Directory)

	if isDir1 != isDir2 {
		return errors.New("arguments do diff must both be directories or both non-directories")
	}

	d, err := diff.NewComparer(os.Stdout)
	if err != nil {
		return errors.Wrap(err, "error creating comparer")
	}
	defer d.Close() //nolint:errcheck

	if *diffCompareFiles {
		parts := strings.Split(*diffCommandCommand, " ")
		d.DiffCommand = parts[0]
		d.DiffArguments = parts[1:]
	}

	if isDir1 {
		return d.Compare(ctx, ent1, ent2)
	}

	return errors.New("comparing files not implemented yet")
}

package main

func main() {
	t := thing{}
	t.add().add().add().add().add().add().add().add().add().add().add().add().add().
		add().add().add().add().add().add().add().add().add().add().add().add().add()
}

type thing struct {
}

func (t thing) add() thing {
	return t
}

./ifshort  -debug vfpst  .

func examples() []string {
	field := os.Getenv("FIELD")
	if field == "" {
		field = "foo"
	}
	return []string{field}
}

variable 'field' is only used in the if-statement (example.go:2:2); consider using short syntax (ifshort)
        field := t.Field
        ^

request.go:48:2: variable 'idx' is only used in the if-statement (request.go:50:2); consider using short syntax (ifshort)

example/main.go:12:2: variable 'delay' is only used in the if-statement (example/main.go:13:2); consider using short syntax (ifshort)
	delay := *delayPtr
	^

test.go:11:2: variable 'value' is only used in the if-statement (test.go:12:2); consider using short syntax (ifshort)
        value := ctx.Value("key")