all: resolve unused value and yoda conditionals staticcheck warnings

Values which are assigned to a variable but unused are either benign,
which cause the code to be confusing to the reader,
or actually lead to bugs, such as missed error checks in some tests.

Also, consistently place the constant on the right side in comparisons.

Signed-off-by: Daniel Martí <[e-mail]>
Change-Id: Icb5ef7c57fd26c6e2f82bf7309ebcbea1c5d0fbe
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/1195056
TryBot-Result: CUEcueckoo <[e-mail]>
Unity-Result: CUE porcuepine <[e-mail]>
Reviewed-by: Roger Peppe <[e-mail]>

cue/build/import.go

···
 
 	if inst.loadFunc != nil {
 		for i, path := range paths {
-			isLocal := IsLocalImport(path)
-			if isLocal {
-				// path = dirToImportPath(filepath.Join(dir, path))
-			}
+			// isLocal := IsLocalImport(path)
+			// if isLocal {
+			// 	path = dirToImportPath(filepath.Join(dir, path))
+			// }
 
 			imp := c.imports[path]
 			if imp == nil {

cue/format/simplify.go

···
 	for _, d := range decls {
 		switch x := d.(type) {
 		case *ast.Field:
-			x = astutil.Apply(x, sc.replace, nil).(*ast.Field)
+			astutil.Apply(x, sc.replace, nil)
 		}
 	}
 }

cue/types.go

···
 
 	case 1:
 		// the default case, processed below.
-		env = c.Env
 		env, expr = c.EnvExpr()
 		if w, ok := expr.(*adt.Vertex); ok {
 			return Value{v.idx, w, v.parent_}.Expr()

internal/httplog/client_test.go

···
 	resp, err := client.Get(srv.URL + "/foo/bar?foo=bar")
 	qt.Assert(t, qt.IsNil(err))
 	data, err := io.ReadAll(resp.Body)
+	qt.Assert(t, qt.IsNil(err))
 	resp.Body.Close()
 	qt.Assert(t, qt.Equals(string(data), "hello"))
 

internal/vcs/vcs_test.go

···
 	qt.Assert(t, qt.IsTrue(!status.CommitTime.Before(commitTime)))
 	qt.Assert(t, qt.Matches(status.Revision, `[0-9a-f]+`))
 	files, err := v.ListFiles(ctx, filepath.Join(dir, "subdir"))
+	qt.Assert(t, qt.IsNil(err))
 	qt.Assert(t, qt.DeepEquals(files, []string{
 		"bar/baz",
 		"foo",
 	}))
 	files, err = v.ListFiles(ctx, dir)
+	qt.Assert(t, qt.IsNil(err))
 	qt.Assert(t, qt.DeepEquals(files, []string{
 		"bar.txt",
 		"baz/something",

pkg/list/math.go

···
 
 // Avg returns the average value of a non empty list xs.
 func Avg(xs []*internal.Decimal) (*internal.Decimal, error) {
-	if 0 == len(xs) {
+	if len(xs) == 0 {
 		return nil, fmt.Errorf("empty list")
 	}
 
···
 
 // Max returns the maximum value of a non empty list xs.
 func Max(xs []*internal.Decimal) (*internal.Decimal, error) {
-	if 0 == len(xs) {
+	if len(xs) == 0 {
 		return nil, fmt.Errorf("empty list")
 	}
 
 	max := xs[0]
 	for _, x := range xs[1:] {
-		if -1 == max.Cmp(x) {
+		if max.Cmp(x) == -1 {
 			max = x
 		}
 	}
···
 
 // Min returns the minimum value of a non empty list xs.
 func Min(xs []*internal.Decimal) (*internal.Decimal, error) {
-	if 0 == len(xs) {
+	if len(xs) == 0 {
 		return nil, fmt.Errorf("empty list")
 	}
 
 	min := xs[0]
 	for _, x := range xs[1:] {
-		if +1 == min.Cmp(x) {
+		if min.Cmp(x) == +1 {
 			min = x
 		}
 	}
···
 		return nil, fmt.Errorf("step must be non zero")
 	}
 
-	if !step.Negative && +1 == start.Cmp(limit) {
+	if !step.Negative && start.Cmp(limit) == +1 {
 		return nil, fmt.Errorf("end must be greater than start when step is positive")
 	}
 
-	if step.Negative && -1 == start.Cmp(limit) {
+	if step.Negative && start.Cmp(limit) == -1 {
 		return nil, fmt.Errorf("end must be less than start when step is negative")
 	}
 
 	var vals []*internal.Decimal
 	num := start
 	for {
-		if !step.Negative && -1 != num.Cmp(limit) {
+		if !step.Negative && num.Cmp(limit) != -1 {
 			break
 		}
 
-		if step.Negative && +1 != num.Cmp(limit) {
+		if step.Negative && num.Cmp(limit) != +1 {
 			break
 		}