diff --git a/cache/manager.go b/cache/manager.go
index 69f684db..bf673968 100644
--- a/cache/manager.go
+++ b/cache/manager.go
@@ -412,8 +412,5 @@ func initializeMetadata(m withMetadata, opts ...RefOption) error {
 		return err
 	}
 
-	if err := md.Commit(); err != nil {
-		return err
-	}
-	return nil
+	return md.Commit()
 }
diff --git a/cache/manager_test.go b/cache/manager_test.go
index 3efee5b0..e9603c6c 100644
--- a/cache/manager_test.go
+++ b/cache/manager_test.go
@@ -31,7 +31,7 @@ func TestManager(t *testing.T) {
 	_, err = cm.Get(ctx, "foobar")
 	require.Error(t, err)
 
-	checkDiskUsage(t, ctx, cm, 0, 0)
+	checkDiskUsage(ctx, t, cm, 0, 0)
 
 	active, err := cm.New(ctx, nil, CachePolicyRetain)
 	require.NoError(t, err)
@@ -54,12 +54,12 @@ func TestManager(t *testing.T) {
 	require.Error(t, err)
 	require.Equal(t, errLocked, errors.Cause(err))
 
-	checkDiskUsage(t, ctx, cm, 1, 0)
+	checkDiskUsage(ctx, t, cm, 1, 0)
 
 	snap, err := active.Commit(ctx)
 	require.NoError(t, err)
 
-	checkDiskUsage(t, ctx, cm, 1, 0)
+	checkDiskUsage(ctx, t, cm, 1, 0)
 
 	_, err = cm.GetMutable(ctx, active.ID())
 	require.Error(t, err)
@@ -68,17 +68,17 @@ func TestManager(t *testing.T) {
 	err = snap.Release(ctx)
 	require.NoError(t, err)
 
-	checkDiskUsage(t, ctx, cm, 0, 1)
+	checkDiskUsage(ctx, t, cm, 0, 1)
 
 	active, err = cm.GetMutable(ctx, active.ID())
 	require.NoError(t, err)
 
-	checkDiskUsage(t, ctx, cm, 1, 0)
+	checkDiskUsage(ctx, t, cm, 1, 0)
 
 	snap, err = active.Commit(ctx)
 	require.NoError(t, err)
 
-	checkDiskUsage(t, ctx, cm, 1, 0)
+	checkDiskUsage(ctx, t, cm, 1, 0)
 
 	err = snap.Finalize(ctx)
 	require.NoError(t, err)
@@ -100,7 +100,7 @@ func TestManager(t *testing.T) {
 	snap2, err := cm.Get(ctx, snap.ID())
 	require.NoError(t, err)
 
-	checkDiskUsage(t, ctx, cm, 1, 0)
+	checkDiskUsage(ctx, t, cm, 1, 0)
 
 	err = snap.Release(ctx)
 	require.NoError(t, err)
@@ -108,7 +108,7 @@ func TestManager(t *testing.T) {
 	active2, err := cm.New(ctx, snap2, CachePolicyRetain)
 	require.NoError(t, err)
 
-	checkDiskUsage(t, ctx, cm, 2, 0)
+	checkDiskUsage(ctx, t, cm, 2, 0)
 
 	snap3, err := active2.Commit(ctx)
 	require.NoError(t, err)
@@ -116,12 +116,12 @@ func TestManager(t *testing.T) {
 	err = snap2.Release(ctx)
 	require.NoError(t, err)
 
-	checkDiskUsage(t, ctx, cm, 2, 0)
+	checkDiskUsage(ctx, t, cm, 2, 0)
 
 	err = snap3.Release(ctx)
 	require.NoError(t, err)
 
-	checkDiskUsage(t, ctx, cm, 0, 2)
+	checkDiskUsage(ctx, t, cm, 0, 2)
 
 	err = cm.Close()
 	require.NoError(t, err)
@@ -267,7 +267,7 @@ func getCacheManager(t *testing.T, tmpdir string, snapshotter snapshot.Snapshott
 	return cm
 }
 
-func checkDiskUsage(t *testing.T, ctx context.Context, cm Manager, inuse, unused int) {
+func checkDiskUsage(ctx context.Context, t *testing.T, cm Manager, inuse, unused int) {
 	du, err := cm.DiskUsage(ctx, client.DiskUsageInfo{})
 	require.NoError(t, err)
 	var inuseActual, unusedActual int
diff --git a/cache/refs.go b/cache/refs.go
index 1b46c214..66a30fdc 100644
--- a/cache/refs.go
+++ b/cache/refs.go
@@ -214,30 +214,30 @@ func (sr *immutableRef) Finalize(ctx context.Context) error {
 	return sr.finalize(ctx)
 }
 
-func (sr *cacheRecord) Metadata() *metadata.StorageItem {
-	return sr.md
+func (cr *cacheRecord) Metadata() *metadata.StorageItem {
+	return cr.md
 }
 
-func (sr *cacheRecord) finalize(ctx context.Context) error {
-	mutable := sr.equalMutable
+func (cr *cacheRecord) finalize(ctx context.Context) error {
+	mutable := cr.equalMutable
 	if mutable == nil {
 		return nil
 	}
-	err := sr.cm.Snapshotter.Commit(ctx, sr.ID(), mutable.ID())
+	err := cr.cm.Snapshotter.Commit(ctx, cr.ID(), mutable.ID())
 	if err != nil {
 		return errors.Wrapf(err, "failed to commit %s", mutable.ID())
 	}
 	mutable.dead = true
 	go func() {
-		sr.cm.mu.Lock()
-		defer sr.cm.mu.Unlock()
+		cr.cm.mu.Lock()
+		defer cr.cm.mu.Unlock()
 		if err := mutable.remove(context.TODO(), false); err != nil {
 			logrus.Error(err)
 		}
 	}()
-	sr.equalMutable = nil
-	clearEqualMutable(sr.md)
-	return sr.md.Commit()
+	cr.equalMutable = nil
+	clearEqualMutable(cr.md)
+	return cr.md.Commit()
 }
 
 func (sr *mutableRef) commit(ctx context.Context) (ImmutableRef, error) {
diff --git a/session/grpchijack/dial.go b/session/grpchijack/dial.go
index c820bb9a..96fbcd24 100644
--- a/session/grpchijack/dial.go
+++ b/session/grpchijack/dial.go
@@ -80,26 +80,26 @@ func (c *conn) Write(b []byte) (int, error) {
 	return len(b), nil
 }
 
-func (s *conn) Close() error {
-	if cs, ok := s.stream.(grpc.ClientStream); ok {
+func (c *conn) Close() error {
+	if cs, ok := c.stream.(grpc.ClientStream); ok {
 		return cs.CloseSend()
 	}
 	return nil
 }
 
-func (s *conn) LocalAddr() net.Addr {
+func (c *conn) LocalAddr() net.Addr {
 	return dummyAddr{}
 }
-func (s *conn) RemoteAddr() net.Addr {
+func (c *conn) RemoteAddr() net.Addr {
 	return dummyAddr{}
 }
-func (s *conn) SetDeadline(t time.Time) error {
+func (c *conn) SetDeadline(t time.Time) error {
 	return nil
 }
-func (s *conn) SetReadDeadline(t time.Time) error {
+func (c *conn) SetReadDeadline(t time.Time) error {
 	return nil
 }
-func (s *conn) SetWriteDeadline(t time.Time) error {
+func (c *conn) SetWriteDeadline(t time.Time) error {
 	return nil
 }
 
diff --git a/snapshot/blobmapping/snapshotter.go b/snapshot/blobmapping/snapshotter.go
index 586d0b82..fb66dca5 100644
--- a/snapshot/blobmapping/snapshotter.go
+++ b/snapshot/blobmapping/snapshotter.go
@@ -45,7 +45,7 @@ func NewSnapshotter(opt Opt) (*Snapshotter, error) {
 	return s, nil
 }
 
-// Remove also removes a refrence to a blob. If it is a last reference then it deletes it the blob as well
+// Remove also removes a reference to a blob. If it is a last reference then it deletes it the blob as well
 // Remove is not safe to be called concurrently
 func (s *Snapshotter) Remove(ctx context.Context, key string) error {
 	_, blob, err := s.GetBlob(ctx, key)
diff --git a/solver/jobs.go b/solver/jobs.go
index 93daa594..bdd1c580 100644
--- a/solver/jobs.go
+++ b/solver/jobs.go
@@ -257,7 +257,7 @@ func (j *job) getRef(ctx context.Context, v *vertex, index Index) (Reference, er
 	if err != nil {
 		return nil, err
 	}
-	ref, err := getRef(s, ctx, v, index, j.cache)
+	ref, err := getRef(ctx, s, v, index, j.cache)
 	if err != nil {
 		return nil, err
 	}
@@ -284,7 +284,7 @@ func (j *job) cacheExporter(ref Reference) (CacheExporter, error) {
 	return cr.Cache(cr.index, cr.ref), nil
 }
 
-func getRef(s VertexSolver, ctx context.Context, v *vertex, index Index, cache InstructionCache) (Reference, error) {
+func getRef(ctx context.Context, s VertexSolver, v *vertex, index Index, cache InstructionCache) (Reference, error) {
 	k, err := s.CacheKey(ctx, index)
 	if err != nil {
 		return nil, err
diff --git a/solver/solver.go b/solver/solver.go
index 5d2f7f29..fc30f70b 100644
--- a/solver/solver.go
+++ b/solver/solver.go
@@ -226,7 +226,7 @@ func (s *Solver) subBuild(ctx context.Context, dgst digest.Digest, req SolveRequ
 	st = jl.actives[inp.Vertex.Digest()]
 	jl.mu.Unlock()
 
-	return getRef(st.solver, ctx, inp.Vertex.(*vertex), inp.Index, s.cache) // TODO: combine to pass single input                                        // TODO: export cache for subbuilds
+	return getRef(ctx, st.solver, inp.Vertex.(*vertex), inp.Index, s.cache) // TODO: combine to pass single input                                        // TODO: export cache for subbuilds
 }
 
 type VertexSolver interface {
diff --git a/source/identifier.go b/source/identifier.go
index 1c062cb0..4ee0d162 100644
--- a/source/identifier.go
+++ b/source/identifier.go
@@ -71,6 +71,6 @@ func NewLocalIdentifier(str string) (*LocalIdentifier, error) {
 	return &LocalIdentifier{Name: str}, nil
 }
 
-func (_ *LocalIdentifier) ID() string {
+func (*LocalIdentifier) ID() string {
 	return LocalScheme
 }
diff --git a/util/bgfunc/bgfunc_test.go b/util/bgfunc/bgfunc_test.go
index f0541495..c8d00c31 100644
--- a/util/bgfunc/bgfunc_test.go
+++ b/util/bgfunc/bgfunc_test.go
@@ -174,20 +174,16 @@ func TestCancellation(t *testing.T) {
 
 	c3 := f.NewCaller()
 
-	var cancelFirst func()
 	firstErr := make(chan error)
 	go func() {
-		ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
-		cancelFirst = cancel
+		ctx, _ := context.WithTimeout(context.Background(), 50*time.Millisecond)
 		_, err := c1.Call(ctx, fn1)
 		firstErr <- err
 	}()
 
-	var cancelSecond func()
 	secondErr := make(chan error)
 	go func() {
-		ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
-		cancelSecond = cancel
+		ctx, _ := context.WithTimeout(context.Background(), 100*time.Millisecond)
 		_, err := c2.Call(ctx, fn2)
 		secondErr <- err
 	}()
diff --git a/worker/containerdworker/worker.go b/worker/containerdworker/worker.go
index ffb24242..e0275e92 100644
--- a/worker/containerdworker/worker.go
+++ b/worker/containerdworker/worker.go
@@ -76,10 +76,10 @@ func (w containerdWorker) Exec(ctx context.Context, meta worker.Meta, root cache
 
 type emptyReadCloser struct{}
 
-func (_ *emptyReadCloser) Read([]byte) (int, error) {
+func (*emptyReadCloser) Read([]byte) (int, error) {
 	return 0, io.EOF
 }
 
-func (_ *emptyReadCloser) Close() error {
+func (*emptyReadCloser) Close() error {
 	return nil
 }