chore: vendor

vendor/gotest.tools/v3/internal/source/defers.go

@@ -0,0 +1,52 @@
+package source
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+)
+
+func scanToDeferLine(fileset *token.FileSet, node ast.Node, lineNum int) ast.Node {
+	var matchedNode ast.Node
+	ast.Inspect(node, func(node ast.Node) bool {
+		switch {
+		case node == nil || matchedNode != nil:
+			return false
+		case fileset.Position(node.End()).Line == lineNum:
+			if funcLit, ok := node.(*ast.FuncLit); ok {
+				matchedNode = funcLit
+				return false
+			}
+		}
+		return true
+	})
+	debug("defer line node: %s", debugFormatNode{matchedNode})
+	return matchedNode
+}
+
+func guessDefer(node ast.Node) (ast.Node, error) {
+	defers := collectDefers(node)
+	switch len(defers) {
+	case 0:
+		return nil, fmt.Errorf("failed to find expression in defer")
+	case 1:
+		return defers[0].Call, nil
+	default:
+		return nil, fmt.Errorf(
+			"ambiguous call expression: multiple (%d) defers in call block",
+			len(defers))
+	}
+}
+
+func collectDefers(node ast.Node) []*ast.DeferStmt {
+	var defers []*ast.DeferStmt
+	ast.Inspect(node, func(node ast.Node) bool {
+		if d, ok := node.(*ast.DeferStmt); ok {
+			defers = append(defers, d)
+			debug("defer: %s", debugFormatNode{d})
+			return false
+		}
+		return true
+	})
+	return defers
+}

vendor/gotest.tools/v3/internal/source/source.go

@@ -0,0 +1,148 @@
+// Package source provides utilities for handling source-code.
+package source // import "gotest.tools/v3/internal/source"
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"os"
+	"runtime"
+)
+
+// FormattedCallExprArg returns the argument from an ast.CallExpr at the
+// index in the call stack. The argument is formatted using FormatNode.
+func FormattedCallExprArg(stackIndex int, argPos int) (string, error) {
+	args, err := CallExprArgs(stackIndex + 1)
+	if err != nil {
+		return "", err
+	}
+	if argPos >= len(args) {
+		return "", errors.New("failed to find expression")
+	}
+	return FormatNode(args[argPos])
+}
+
+// CallExprArgs returns the ast.Expr slice for the args of an ast.CallExpr at
+// the index in the call stack.
+func CallExprArgs(stackIndex int) ([]ast.Expr, error) {
+	_, filename, line, ok := runtime.Caller(stackIndex + 1)
+	if !ok {
+		return nil, errors.New("failed to get call stack")
+	}
+	debug("call stack position: %s:%d", filename, line)
+
+	fileset := token.NewFileSet()
+	astFile, err := parser.ParseFile(fileset, filename, nil, parser.AllErrors)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse source file %s: %w", filename, err)
+	}
+
+	expr, err := getCallExprArgs(fileset, astFile, line)
+	if err != nil {
+		return nil, fmt.Errorf("call from %s:%d: %w", filename, line, err)
+	}
+	return expr, nil
+}
+
+func getNodeAtLine(fileset *token.FileSet, astFile ast.Node, lineNum int) (ast.Node, error) {
+	if node := scanToLine(fileset, astFile, lineNum); node != nil {
+		return node, nil
+	}
+	if node := scanToDeferLine(fileset, astFile, lineNum); node != nil {
+		node, err := guessDefer(node)
+		if err != nil || node != nil {
+			return node, err
+		}
+	}
+	return nil, nil
+}
+
+func scanToLine(fileset *token.FileSet, node ast.Node, lineNum int) ast.Node {
+	var matchedNode ast.Node
+	ast.Inspect(node, func(node ast.Node) bool {
+		switch {
+		case node == nil || matchedNode != nil:
+			return false
+		case fileset.Position(node.Pos()).Line == lineNum:
+			matchedNode = node
+			return false
+		}
+		return true
+	})
+	return matchedNode
+}
+
+func getCallExprArgs(fileset *token.FileSet, astFile ast.Node, line int) ([]ast.Expr, error) {
+	node, err := getNodeAtLine(fileset, astFile, line)
+	switch {
+	case err != nil:
+		return nil, err
+	case node == nil:
+		return nil, fmt.Errorf("failed to find an expression")
+	}
+
+	debug("found node: %s", debugFormatNode{node})
+
+	visitor := &callExprVisitor{}
+	ast.Walk(visitor, node)
+	if visitor.expr == nil {
+		return nil, errors.New("failed to find call expression")
+	}
+	debug("callExpr: %s", debugFormatNode{visitor.expr})
+	return visitor.expr.Args, nil
+}
+
+type callExprVisitor struct {
+	expr *ast.CallExpr
+}
+
+func (v *callExprVisitor) Visit(node ast.Node) ast.Visitor {
+	if v.expr != nil || node == nil {
+		return nil
+	}
+	debug("visit: %s", debugFormatNode{node})
+
+	switch typed := node.(type) {
+	case *ast.CallExpr:
+		v.expr = typed
+		return nil
+	case *ast.DeferStmt:
+		ast.Walk(v, typed.Call.Fun)
+		return nil
+	}
+	return v
+}
+
+// FormatNode using go/format.Node and return the result as a string
+func FormatNode(node ast.Node) (string, error) {
+	buf := new(bytes.Buffer)
+	err := format.Node(buf, token.NewFileSet(), node)
+	return buf.String(), err
+}
+
+var debugEnabled = os.Getenv("GOTESTTOOLS_DEBUG") != ""
+
+func debug(format string, args ...interface{}) {
+	if debugEnabled {
+		fmt.Fprintf(os.Stderr, "DEBUG: "+format+"\n", args...)
+	}
+}
+
+type debugFormatNode struct {
+	ast.Node
+}
+
+func (n debugFormatNode) String() string {
+	if n.Node == nil {
+		return "none"
+	}
+	out, err := FormatNode(n.Node)
+	if err != nil {
+		return fmt.Sprintf("failed to format %s: %s", n.Node, err)
+	}
+	return fmt.Sprintf("(%T) %s", n.Node, out)
+}

vendor/gotest.tools/v3/internal/source/update.go

@@ -0,0 +1,171 @@
+package source
+
+import (
+	"bytes"
+	"errors"
+	"flag"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"os"
+	"runtime"
+	"strings"
+)
+
+// IsUpdate is returns true if the -update flag is set. It indicates the user
+// running the tests would like to update any golden values.
+func IsUpdate() bool {
+	if Update {
+		return true
+	}
+	return flag.Lookup("update").Value.(flag.Getter).Get().(bool)
+}
+
+// Update is a shim for testing, and for compatibility with the old -update-golden
+// flag.
+var Update bool
+
+func init() {
+	if f := flag.Lookup("update"); f != nil {
+		getter, ok := f.Value.(flag.Getter)
+		msg := "some other package defined an incompatible -update flag, expected a flag.Bool"
+		if !ok {
+			panic(msg)
+		}
+		if _, ok := getter.Get().(bool); !ok {
+			panic(msg)
+		}
+		return
+	}
+	flag.Bool("update", false, "update golden values")
+}
+
+// ErrNotFound indicates that UpdateExpectedValue failed to find the
+// variable to update, likely because it is not a package level variable.
+var ErrNotFound = fmt.Errorf("failed to find variable for update of golden value")
+
+// UpdateExpectedValue looks for a package-level variable with a name that
+// starts with expected in the arguments to the caller. If the variable is
+// found, the value of the variable will be updated to value of the other
+// argument to the caller.
+func UpdateExpectedValue(stackIndex int, x, y interface{}) error {
+	_, filename, line, ok := runtime.Caller(stackIndex + 1)
+	if !ok {
+		return errors.New("failed to get call stack")
+	}
+	debug("call stack position: %s:%d", filename, line)
+
+	fileset := token.NewFileSet()
+	astFile, err := parser.ParseFile(fileset, filename, nil, parser.AllErrors|parser.ParseComments)
+	if err != nil {
+		return fmt.Errorf("failed to parse source file %s: %w", filename, err)
+	}
+
+	expr, err := getCallExprArgs(fileset, astFile, line)
+	if err != nil {
+		return fmt.Errorf("call from %s:%d: %w", filename, line, err)
+	}
+
+	if len(expr) < 3 {
+		debug("not enough arguments %d: %v",
+			len(expr), debugFormatNode{Node: &ast.CallExpr{Args: expr}})
+		return ErrNotFound
+	}
+
+	argIndex, ident := getIdentForExpectedValueArg(expr)
+	if argIndex < 0 || ident == nil {
+		debug("no arguments started with the word 'expected': %v",
+			debugFormatNode{Node: &ast.CallExpr{Args: expr}})
+		return ErrNotFound
+	}
+
+	value := x
+	if argIndex == 1 {
+		value = y
+	}
+
+	strValue, ok := value.(string)
+	if !ok {
+		debug("value must be type string, got %T", value)
+		return ErrNotFound
+	}
+	return UpdateVariable(filename, fileset, astFile, ident, strValue)
+}
+
+// UpdateVariable writes to filename the contents of astFile with the value of
+// the variable updated to value.
+func UpdateVariable(
+	filename string,
+	fileset *token.FileSet,
+	astFile *ast.File,
+	ident *ast.Ident,
+	value string,
+) error {
+	obj := ident.Obj
+	if obj == nil {
+		return ErrNotFound
+	}
+	if obj.Kind != ast.Con && obj.Kind != ast.Var {
+		debug("can only update var and const, found %v", obj.Kind)
+		return ErrNotFound
+	}
+
+	switch decl := obj.Decl.(type) {
+	case *ast.ValueSpec:
+		if len(decl.Names) != 1 {
+			debug("more than one name in ast.ValueSpec")
+			return ErrNotFound
+		}
+
+		decl.Values[0] = &ast.BasicLit{
+			Kind:  token.STRING,
+			Value: "`" + value + "`",
+		}
+
+	case *ast.AssignStmt:
+		if len(decl.Lhs) != 1 {
+			debug("more than one name in ast.AssignStmt")
+			return ErrNotFound
+		}
+
+		decl.Rhs[0] = &ast.BasicLit{
+			Kind:  token.STRING,
+			Value: "`" + value + "`",
+		}
+
+	default:
+		debug("can only update *ast.ValueSpec, found %T", obj.Decl)
+		return ErrNotFound
+	}
+
+	var buf bytes.Buffer
+	if err := format.Node(&buf, fileset, astFile); err != nil {
+		return fmt.Errorf("failed to format file after update: %w", err)
+	}
+
+	fh, err := os.Create(filename)
+	if err != nil {
+		return fmt.Errorf("failed to open file %v: %w", filename, err)
+	}
+	if _, err = fh.Write(buf.Bytes()); err != nil {
+		return fmt.Errorf("failed to write file %v: %w", filename, err)
+	}
+	if err := fh.Sync(); err != nil {
+		return fmt.Errorf("failed to sync file %v: %w", filename, err)
+	}
+	return nil
+}
+
+func getIdentForExpectedValueArg(expr []ast.Expr) (int, *ast.Ident) {
+	for i := 1; i < 3; i++ {
+		switch e := expr[i].(type) {
+		case *ast.Ident:
+			if strings.HasPrefix(strings.ToLower(e.Name), "expected") {
+				return i, e
+			}
+		}
+	}
+	return -1, nil
+}

vendor/gotest.tools/v3/internal/source/version.go

@@ -0,0 +1,35 @@
+package source
+
+import (
+	"runtime"
+	"strconv"
+	"strings"
+)
+
+// GoVersionLessThan returns true if runtime.Version() is semantically less than
+// version major.minor. Returns false if a release version can not be parsed from
+// runtime.Version().
+func GoVersionLessThan(major, minor int64) bool {
+	version := runtime.Version()
+	// not a release version
+	if !strings.HasPrefix(version, "go") {
+		return false
+	}
+	version = strings.TrimPrefix(version, "go")
+	parts := strings.Split(version, ".")
+	if len(parts) < 2 {
+		return false
+	}
+	rMajor, err := strconv.ParseInt(parts[0], 10, 32)
+	if err != nil {
+		return false
+	}
+	if rMajor != major {
+		return rMajor < major
+	}
+	rMinor, err := strconv.ParseInt(parts[1], 10, 32)
+	if err != nil {
+		return false
+	}
+	return rMinor < minor
+}