go get -u ./...; go mod tidy

vendor/go.uber.org/mock/mockgen/deprecated.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"flag"
+	"log"
+	"os"
+)
+
+const (
+	deprecatedFlagProgOnly = "prog_only"
+	deprecatedFlagExecOnly = "exec_only"
+)
+
+var (
+	_ = flag.Bool("prog_only", false, "DEPRECATED (reflect mode) Only generate the reflection program; write it to stdout and exit.")
+	_ = flag.String("exec_only", "", "DEPRECATED (reflect mode) If set, execute this reflection program.")
+)
+
+// notifyAboutDeprecatedFlags prints a warning message for a deprecated flags if they are set.
+func notifyAboutDeprecatedFlags() {
+	const resetColorPostfix = "\033[0m"
+	logger := initWarningLogger()
+
+	flag.Visit(func(f *flag.Flag) {
+		switch f.Name {
+		case deprecatedFlagProgOnly:
+			logger.Println("The -prog_only flag is deprecated and has no effect.", resetColorPostfix)
+		case deprecatedFlagExecOnly:
+			logger.Println("The -exec_only flag is deprecated and has no effect.", resetColorPostfix)
+		}
+	})
+}
+
+func initWarningLogger() *log.Logger {
+	const (
+		yellowColor   = "\033[33m"
+		warningPrefix = yellowColor + "WARNING: "
+	)
+
+	return log.New(os.Stdout, warningPrefix, log.Ldate|log.Ltime)
+}

vendor/go.uber.org/mock/mockgen/generic.go

@@ -5,9 +5,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//go:build go1.18
-// +build go1.18
-
 package main
 
 import (
@@ -15,7 +12,6 @@ import (
 	"fmt"
 	"go/ast"
 	"go/token"
-	"strings"
 
 	"go.uber.org/mock/mockgen/model"
 )
@@ -67,29 +63,6 @@ func (p *fileParser) parseGenericType(pkg string, typ ast.Expr, tps map[string]m
 	return nil, nil
 }
 
-func getIdentTypeParams(decl any) string {
-	if decl == nil {
-		return ""
-	}
-	ts, ok := decl.(*ast.TypeSpec)
-	if !ok {
-		return ""
-	}
-	if ts.TypeParams == nil || len(ts.TypeParams.List) == 0 {
-		return ""
-	}
-	var sb strings.Builder
-	sb.WriteString("[")
-	for i, v := range ts.TypeParams.List {
-		if i != 0 {
-			sb.WriteString(", ")
-		}
-		sb.WriteString(v.Names[0].Name)
-	}
-	sb.WriteString("]")
-	return sb.String()
-}
-
 func (p *fileParser) parseGenericMethod(field *ast.Field, it *namedInterface, iface *model.Interface, pkg string, tps map[string]model.Type) ([]*model.Method, error) {
 	var indices []ast.Expr
 	var typ ast.Expr

vendor/go.uber.org/mock/mockgen/generic_notgo118.go

@@ -1,41 +0,0 @@
-// Copyright 2022 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//go:build !go1.18
-// +build !go1.18
-
-package main
-
-import (
-	"fmt"
-	"go/ast"
-
-	"go.uber.org/mock/mockgen/model"
-)
-
-func getTypeSpecTypeParams(ts *ast.TypeSpec) []*ast.Field {
-	return nil
-}
-
-func (p *fileParser) parseGenericType(pkg string, typ ast.Expr, tps map[string]model.Type) (model.Type, error) {
-	return nil, nil
-}
-
-func getIdentTypeParams(decl any) string {
-	return ""
-}
-
-func (p *fileParser) parseGenericMethod(field *ast.Field, it *namedInterface, iface *model.Interface, pkg string, tps map[string]model.Type) ([]*model.Method, error) {
-	return nil, fmt.Errorf("don't know how to mock method of type %T", field.Type)
-}

vendor/go.uber.org/mock/mockgen/gob.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"encoding/gob"
+	"os"
+
+	"go.uber.org/mock/mockgen/model"
+)
+
+func gobMode(path string) (*model.Package, error) {
+	in, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer in.Close()
+	var pkg model.Package
+	if err := gob.NewDecoder(in).Decode(&pkg); err != nil {
+		return nil, err
+	}
+	return &pkg, nil
+}

vendor/go.uber.org/mock/mockgen/mockgen.go

@@ -59,14 +59,17 @@ var (
 	mockNames              = flag.String("mock_names", "", "Comma-separated interfaceName=mockName pairs of explicit mock names to use. Mock names default to 'Mock'+ interfaceName suffix.")
 	packageOut             = flag.String("package", "", "Package of the generated code; defaults to the package of the input with a 'mock_' prefix.")
 	selfPackage            = flag.String("self_package", "", "The full package import path for the generated code. The purpose of this flag is to prevent import cycles in the generated code by trying to include its own package. This can happen if the mock's package is set to one of its inputs (usually the main one) and the output is stdio so mockgen cannot detect the final output package. Setting this flag will then tell mockgen which import to exclude.")
+	writeCmdComment        = flag.Bool("write_command_comment", true, "Writes the command used as a comment if true.")
 	writePkgComment        = flag.Bool("write_package_comment", true, "Writes package documentation comment (godoc) if true.")
-	writeSourceComment     = flag.Bool("write_source_comment", true, "Writes original file (source mode) or interface names (reflect mode) comment if true.")
+	writeSourceComment     = flag.Bool("write_source_comment", true, "Writes original file (source mode) or interface names (package mode) comment if true.")
 	writeGenerateDirective = flag.Bool("write_generate_directive", false, "Add //go:generate directive to regenerate the mock")
 	copyrightFile          = flag.String("copyright_file", "", "Copyright file used to add copyright header")
+	buildConstraint        = flag.String("build_constraint", "", "If non-empty, added as //go:build <constraint>")
 	typed                  = flag.Bool("typed", false, "Generate Type-safe 'Return', 'Do', 'DoAndReturn' function")
 	imports                = flag.String("imports", "", "(source mode) Comma-separated name=path pairs of explicit imports to use.")
 	auxFiles               = flag.String("aux_files", "", "(source mode) Comma-separated pkg=path pairs of auxiliary Go source files.")
-	excludeInterfaces      = flag.String("exclude_interfaces", "", "Comma-separated names of interfaces to be excluded")
+	excludeInterfaces      = flag.String("exclude_interfaces", "", "(source mode) Comma-separated names of interfaces to be excluded")
+	modelGob               = flag.String("model_gob", "", "Skip package/source loading entirely and use the gob encoded model.Package at the given path")
 
 	debugParser = flag.Bool("debug_parser", false, "Print out parser results only.")
 	showVersion = flag.Bool("version", false, "Print version.")
@@ -76,6 +79,8 @@ func main() {
 	flag.Usage = usage
 	flag.Parse()
 
+	notifyAboutDeprecatedFlags()
+
 	if *showVersion {
 		printVersion()
 		return
@@ -84,7 +89,9 @@ func main() {
 	var pkg *model.Package
 	var err error
 	var packageName string
-	if *source != "" {
+	if *modelGob != "" {
+		pkg, err = gobMode(*modelGob)
+	} else if *source != "" {
 		pkg, err = sourceMode(*source)
 	} else {
 		if flag.NArg() != 2 {
@@ -103,7 +110,8 @@ func main() {
 				log.Fatalf("Parse package name failed: %v", err)
 			}
 		}
-		pkg, err = reflectMode(packageName, interfaces)
+		parser := packageModeParser{}
+		pkg, err = parser.parsePackage(packageName, interfaces)
 	}
 	if err != nil {
 		log.Fatalf("Loading input failed: %v", err)
@@ -116,7 +124,7 @@ func main() {
 
 	outputPackageName := *packageOut
 	if outputPackageName == "" {
-		// pkg.Name in reflect mode is the base name of the import path,
+		// pkg.Name in package mode is the base name of the import path,
 		// which might have characters that are illegal to have in package names.
 		outputPackageName = "mock_" + sanitize(pkg.Name)
 	}
@@ -142,7 +150,9 @@ func main() {
 		}
 	}
 
-	g := new(generator)
+	g := &generator{
+		buildConstraint: *buildConstraint,
+	}
 	if *source != "" {
 		g.filename = *source
 	} else {
@@ -225,20 +235,21 @@ func usage() {
 	flag.PrintDefaults()
 }
 
-const usageText = `mockgen has two modes of operation: source and reflect.
+const usageText = `mockgen has two modes of operation: source and package.
 
 Source mode generates mock interfaces from a source file.
 It is enabled by using the -source flag. Other flags that
-may be useful in this mode are -imports and -aux_files.
+may be useful in this mode are -imports, -aux_files and -exclude_interfaces.
 Example:
 	mockgen -source=foo.go [other options]
 
-Reflect mode generates mock interfaces by building a program
-that uses reflection to understand interfaces. It is enabled
-by passing two non-flag arguments: an import path, and a
-comma-separated list of symbols.
+Package mode works by specifying the package and interface names.
+It is enabled by passing two non-flag arguments: an import path, and a
+comma-separated list of symbols. 
+You can use "." to refer to the current path's package.
 Example:
 	mockgen database/sql/driver Conn,Driver
+	mockgen . SomeInterface
 
 `
 
@@ -250,12 +261,13 @@ type generator struct {
 	destination               string            // may be empty
 	srcPackage, srcInterfaces string            // may be empty
 	copyrightHeader           string
+	buildConstraint           string // may be empty
 
 	packageMap map[string]string // map from import path to package name
 }
 
 func (g *generator) p(format string, args ...any) {
-	fmt.Fprintf(&g.buf, g.indent+format+"\n", args...)
+	_, _ = fmt.Fprintf(&g.buf, g.indent+format+"\n", args...)
 }
 
 func (g *generator) in() {
@@ -305,6 +317,12 @@ func (g *generator) Generate(pkg *model.Package, outputPkgName string, outputPac
 		g.p("")
 	}
 
+	if g.buildConstraint != "" {
+		g.p("//go:build %s", g.buildConstraint)
+		// https://pkg.go.dev/cmd/go#hdr-Build_constraints:~:text=a%20build%20constraint%20should%20be%20followed%20by%20a%20blank%20line
+		g.p("")
+	}
+
 	g.p("// Code generated by MockGen. DO NOT EDIT.")
 	if *writeSourceComment {
 		if g.filename != "" {
@@ -313,16 +331,18 @@ func (g *generator) Generate(pkg *model.Package, outputPkgName string, outputPac
 			g.p("// Source: %v (interfaces: %v)", g.srcPackage, g.srcInterfaces)
 		}
 	}
-	g.p("//")
-	g.p("// Generated by this command:")
-	g.p("//")
-	// only log the name of the executable, not the full path
-	name := filepath.Base(os.Args[0])
-	if runtime.GOOS == "windows" {
-		name = strings.TrimSuffix(name, ".exe")
+	if *writeCmdComment {
+		g.p("//")
+		g.p("// Generated by this command:")
+		g.p("//")
+		// only log the name of the executable, not the full path
+		name := filepath.Base(os.Args[0])
+		if runtime.GOOS == "windows" {
+			name = strings.TrimSuffix(name, ".exe")
+		}
+		g.p("//\t%v", strings.Join(append([]string{name}, os.Args[1:]...), " "))
+		g.p("//")
 	}
-	g.p("//\t%v", strings.Join(append([]string{name}, os.Args[1:]...), " "))
-	g.p("//")
 
 	// Get all required imports, and generate unique names for them all.
 	im := pkg.Imports()
@@ -392,11 +412,13 @@ func (g *generator) Generate(pkg *model.Package, outputPkgName string, outputPac
 		localNames[pkgName] = true
 	}
 
-	if *writePkgComment {
-		// Ensure there's an empty line before the package to follow the recommendations:
-		// https://github.com/golang/go/wiki/CodeReviewComments#package-comments
-		g.p("")
+	// Ensure there is an empty line between “generated by” block and
+	// package documentation comments to follow the recommendations:
+	// https://go.dev/wiki/CodeReviewComments#package-comments
+	// That is, “generated by” should not be a package comment.
+	g.p("")
 
+	if *writePkgComment {
 		g.p("// Package %v is a generated GoMock package.", outputPkgName)
 	}
 	g.p("package %v", outputPkgName)
@@ -472,6 +494,7 @@ func (g *generator) GenerateMockInterface(intf *model.Interface, outputPackagePa
 	g.in()
 	g.p("ctrl     *gomock.Controller")
 	g.p("recorder *%vMockRecorder%v", mockType, shortTp)
+	g.p("isgomock struct{}")
 	g.out()
 	g.p("}")
 	g.p("")
@@ -816,7 +839,7 @@ func createPackageMap(importPaths []string) map[string]string {
 	}
 	pkgMap := make(map[string]string)
 	b := bytes.NewBuffer(nil)
-	args := []string{"list", "-json"}
+	args := []string{"list", "-json=ImportPath,Name"}
 	args = append(args, importPaths...)
 	cmd := exec.Command("go", args...)
 	cmd.Stdout = b

vendor/go.uber.org/mock/mockgen/package_mode.go

@@ -0,0 +1,358 @@
+package main
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"go/types"
+	"strings"
+
+	"go.uber.org/mock/mockgen/model"
+	"golang.org/x/tools/go/packages"
+)
+
+var (
+	buildFlags = flag.String("build_flags", "", "(package mode) Additional flags for go build.")
+)
+
+type packageModeParser struct {
+	pkgName string
+}
+
+func (p *packageModeParser) parsePackage(packageName string, ifaces []string) (*model.Package, error) {
+	p.pkgName = packageName
+
+	pkg, err := p.loadPackage(packageName)
+	if err != nil {
+		return nil, fmt.Errorf("load package: %w", err)
+	}
+
+	interfaces, err := p.extractInterfacesFromPackage(pkg, ifaces)
+	if err != nil {
+		return nil, fmt.Errorf("extract interfaces from package: %w", err)
+	}
+
+	return &model.Package{
+		Name:       pkg.Types.Name(),
+		PkgPath:    packageName,
+		Interfaces: interfaces,
+	}, nil
+}
+
+func (p *packageModeParser) loadPackage(packageName string) (*packages.Package, error) {
+	var buildFlagsSet []string
+	if *buildFlags != "" {
+		buildFlagsSet = strings.Split(*buildFlags, " ")
+	}
+
+	cfg := &packages.Config{
+		Mode:       packages.NeedDeps | packages.NeedImports | packages.NeedTypes | packages.NeedTypesInfo | packages.NeedEmbedFiles,
+		BuildFlags: buildFlagsSet,
+	}
+	pkgs, err := packages.Load(cfg, packageName)
+	if err != nil {
+		return nil, fmt.Errorf("load packages: %w", err)
+	}
+
+	if len(pkgs) != 1 {
+		return nil, fmt.Errorf("packages length must be 1: %d", len(pkgs))
+	}
+
+	if len(pkgs[0].Errors) > 0 {
+		errs := make([]error, len(pkgs[0].Errors))
+		for i, err := range pkgs[0].Errors {
+			errs[i] = err
+		}
+
+		return nil, errors.Join(errs...)
+	}
+
+	return pkgs[0], nil
+}
+
+func (p *packageModeParser) extractInterfacesFromPackage(pkg *packages.Package, ifaces []string) ([]*model.Interface, error) {
+	interfaces := make([]*model.Interface, len(ifaces))
+	for i, iface := range ifaces {
+		obj := pkg.Types.Scope().Lookup(iface)
+		if obj == nil {
+			return nil, fmt.Errorf("interface %s does not exist", iface)
+		}
+
+		modelIface, err := p.parseInterface(obj)
+		if err != nil {
+			return nil, newParseTypeError("parse interface", obj.Name(), err)
+		}
+
+		interfaces[i] = modelIface
+	}
+
+	return interfaces, nil
+}
+
+func (p *packageModeParser) parseInterface(obj types.Object) (*model.Interface, error) {
+	named, ok := types.Unalias(obj.Type()).(*types.Named)
+	if !ok {
+		return nil, fmt.Errorf("%s is not an interface. it is a %T", obj.Name(), obj.Type().Underlying())
+	}
+
+	iface, ok := named.Underlying().(*types.Interface)
+	if !ok {
+		return nil, fmt.Errorf("%s is not an interface. it is a %T", obj.Name(), obj.Type().Underlying())
+	}
+
+	if p.isConstraint(iface) {
+		return nil, fmt.Errorf("interface %s is a constraint", obj.Name())
+	}
+
+	methods := make([]*model.Method, iface.NumMethods())
+	for i := range iface.NumMethods() {
+		method := iface.Method(i)
+		typedMethod, ok := method.Type().(*types.Signature)
+		if !ok {
+			return nil, fmt.Errorf("method %s is not a signature", method.Name())
+		}
+
+		modelFunc, err := p.parseFunc(typedMethod)
+		if err != nil {
+			return nil, newParseTypeError("parse method", typedMethod.String(), err)
+		}
+
+		methods[i] = &model.Method{
+			Name:     method.Name(),
+			In:       modelFunc.In,
+			Out:      modelFunc.Out,
+			Variadic: modelFunc.Variadic,
+		}
+	}
+
+	if named.TypeParams() == nil {
+		return &model.Interface{Name: obj.Name(), Methods: methods}, nil
+	}
+
+	typeParams := make([]*model.Parameter, named.TypeParams().Len())
+	for i := range named.TypeParams().Len() {
+		param := named.TypeParams().At(i)
+		typeParam, err := p.parseConstraint(param)
+		if err != nil {
+			return nil, newParseTypeError("parse type parameter", param.String(), err)
+		}
+
+		typeParams[i] = &model.Parameter{Name: param.Obj().Name(), Type: typeParam}
+	}
+
+	return &model.Interface{Name: obj.Name(), Methods: methods, TypeParams: typeParams}, nil
+}
+
+func (o *packageModeParser) isConstraint(t *types.Interface) bool {
+	for i := range t.NumEmbeddeds() {
+		embed := t.EmbeddedType(i)
+		if _, ok := embed.Underlying().(*types.Interface); !ok {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (p *packageModeParser) parseType(t types.Type) (model.Type, error) {
+	switch t := t.(type) {
+	case *types.Array:
+		elementType, err := p.parseType(t.Elem())
+		if err != nil {
+			return nil, newParseTypeError("parse array type", t.Elem().String(), err)
+		}
+		return &model.ArrayType{Len: int(t.Len()), Type: elementType}, nil
+	case *types.Slice:
+		elementType, err := p.parseType(t.Elem())
+		if err != nil {
+			return nil, newParseTypeError("parse slice type", t.Elem().String(), err)
+		}
+
+		return &model.ArrayType{Len: -1, Type: elementType}, nil
+	case *types.Chan:
+		var dir model.ChanDir
+		switch t.Dir() {
+		case types.RecvOnly:
+			dir = model.RecvDir
+		case types.SendOnly:
+			dir = model.SendDir
+		}
+
+		chanType, err := p.parseType(t.Elem())
+		if err != nil {
+			return nil, newParseTypeError("parse chan type", t.Elem().String(), err)
+		}
+
+		return &model.ChanType{Dir: dir, Type: chanType}, nil
+	case *types.Signature:
+		sig, err := p.parseFunc(t)
+		if err != nil {
+			return nil, newParseTypeError("parse signature", t.String(), err)
+		}
+
+		return sig, nil
+	case *types.Named, *types.Alias:
+		object := t.(interface{ Obj() *types.TypeName })
+		var pkg string
+		if object.Obj().Pkg() != nil {
+			pkg = object.Obj().Pkg().Path()
+		}
+
+		// TypeArgs method not available for aliases in go1.22
+		genericType, ok := t.(interface{ TypeArgs() *types.TypeList })
+		if !ok || genericType.TypeArgs() == nil {
+			return &model.NamedType{
+				Package: pkg,
+				Type:    object.Obj().Name(),
+			}, nil
+		}
+
+		typeParams := &model.TypeParametersType{TypeParameters: make([]model.Type, genericType.TypeArgs().Len())}
+		for i := range genericType.TypeArgs().Len() {
+			typeParam := genericType.TypeArgs().At(i)
+			typedParam, err := p.parseType(typeParam)
+			if err != nil {
+				return nil, newParseTypeError("parse type parameter", typeParam.String(), err)
+			}
+
+			typeParams.TypeParameters[i] = typedParam
+		}
+
+		return &model.NamedType{
+			Package:    pkg,
+			Type:       object.Obj().Name(),
+			TypeParams: typeParams,
+		}, nil
+	case *types.Interface:
+		if t.Empty() {
+			return model.PredeclaredType("any"), nil
+		}
+
+		return nil, fmt.Errorf("cannot handle non-empty unnamed interfaces")
+	case *types.Map:
+		key, err := p.parseType(t.Key())
+		if err != nil {
+			return nil, newParseTypeError("parse map key", t.Key().String(), err)
+		}
+		value, err := p.parseType(t.Elem())
+		if err != nil {
+			return nil, newParseTypeError("parse map value", t.Elem().String(), err)
+		}
+
+		return &model.MapType{Key: key, Value: value}, nil
+	case *types.Pointer:
+		valueType, err := p.parseType(t.Elem())
+		if err != nil {
+			return nil, newParseTypeError("parse pointer type", t.Elem().String(), err)
+		}
+
+		return &model.PointerType{Type: valueType}, nil
+	case *types.Struct:
+		if t.NumFields() > 0 {
+			return nil, fmt.Errorf("cannot handle non-empty unnamed structs")
+		}
+
+		return model.PredeclaredType("struct{}"), nil
+	case *types.Basic:
+		return model.PredeclaredType(t.Name()), nil
+	case *types.Tuple:
+		panic("tuple field") // TODO
+	case *types.TypeParam:
+		return &model.NamedType{Type: t.Obj().Name()}, nil
+	default:
+		panic("unknown type") // TODO
+	}
+}
+
+func (p *packageModeParser) parseFunc(sig *types.Signature) (*model.FuncType, error) {
+	var variadic *model.Parameter
+	params := make([]*model.Parameter, 0, sig.Params().Len())
+	for i := range sig.Params().Len() {
+		param := sig.Params().At(i)
+
+		isVariadicParam := i == sig.Params().Len()-1 && sig.Variadic()
+		parseType := param.Type()
+		if isVariadicParam {
+			sliceType, ok := param.Type().(*types.Slice)
+			if !ok {
+				return nil, newParseTypeError("variadic parameter is not a slice", param.String(), nil)
+			}
+
+			parseType = sliceType.Elem()
+		}
+
+		paramType, err := p.parseType(parseType)
+		if err != nil {
+			return nil, newParseTypeError("parse parameter type", parseType.String(), err)
+		}
+
+		modelParameter := &model.Parameter{Type: paramType, Name: param.Name()}
+
+		if isVariadicParam {
+			variadic = modelParameter
+		} else {
+			params = append(params, modelParameter)
+		}
+	}
+
+	if len(params) == 0 {
+		params = nil
+	}
+
+	results := make([]*model.Parameter, sig.Results().Len())
+	for i := range sig.Results().Len() {
+		result := sig.Results().At(i)
+
+		resultType, err := p.parseType(result.Type())
+		if err != nil {
+			return nil, newParseTypeError("parse result type", result.Type().String(), err)
+		}
+
+		results[i] = &model.Parameter{Type: resultType, Name: result.Name()}
+	}
+
+	if len(results) == 0 {
+		results = nil
+	}
+
+	return &model.FuncType{
+		In:       params,
+		Out:      results,
+		Variadic: variadic,
+	}, nil
+}
+
+func (p *packageModeParser) parseConstraint(t *types.TypeParam) (model.Type, error) {
+	if t == nil {
+		return nil, fmt.Errorf("nil type param")
+	}
+
+	typeParam, err := p.parseType(t.Constraint())
+	if err != nil {
+		return nil, newParseTypeError("parse constraint type", t.Constraint().String(), err)
+	}
+
+	return typeParam, nil
+}
+
+type parseTypeError struct {
+	message    string
+	typeString string
+	error      error
+}
+
+func newParseTypeError(message string, typeString string, error error) *parseTypeError {
+	return &parseTypeError{typeString: typeString, error: error, message: message}
+}
+
+func (p parseTypeError) Error() string {
+	if p.error != nil {
+		return fmt.Sprintf("%s: error parsing %s: %s", p.message, p.typeString, p.error)
+	}
+
+	return fmt.Sprintf("%s: error parsing type %s", p.message, p.typeString)
+}
+
+func (p parseTypeError) Unwrap() error {
+	return p.error
+}

vendor/go.uber.org/mock/mockgen/reflect.go

@@ -1,256 +0,0 @@
-// Copyright 2012 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package main
-
-// This file contains the model construction by reflection.
-
-import (
-	"bytes"
-	"encoding/gob"
-	"flag"
-	"fmt"
-	"go/build"
-	"io"
-	"log"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"text/template"
-
-	"go.uber.org/mock/mockgen/model"
-)
-
-var (
-	progOnly   = flag.Bool("prog_only", false, "(reflect mode) Only generate the reflection program; write it to stdout and exit.")
-	execOnly   = flag.String("exec_only", "", "(reflect mode) If set, execute this reflection program.")
-	buildFlags = flag.String("build_flags", "", "(reflect mode) Additional flags for go build.")
-)
-
-// reflectMode generates mocks via reflection on an interface.
-func reflectMode(importPath string, symbols []string) (*model.Package, error) {
-	if *execOnly != "" {
-		return run(*execOnly)
-	}
-
-	program, err := writeProgram(importPath, symbols)
-	if err != nil {
-		return nil, err
-	}
-
-	if *progOnly {
-		if _, err := os.Stdout.Write(program); err != nil {
-			return nil, err
-		}
-		os.Exit(0)
-	}
-
-	wd, _ := os.Getwd()
-
-	// Try to run the reflection program  in the current working directory.
-	if p, err := runInDir(program, wd); err == nil {
-		return p, nil
-	}
-
-	// Try to run the program in the same directory as the input package.
-	if p, err := build.Import(importPath, wd, build.FindOnly); err == nil {
-		dir := p.Dir
-		if p, err := runInDir(program, dir); err == nil {
-			return p, nil
-		}
-	}
-
-	// Try to run it in a standard temp directory.
-	return runInDir(program, "")
-}
-
-func writeProgram(importPath string, symbols []string) ([]byte, error) {
-	var program bytes.Buffer
-	data := reflectData{
-		ImportPath: importPath,
-		Symbols:    symbols,
-	}
-	if err := reflectProgram.Execute(&program, &data); err != nil {
-		return nil, err
-	}
-	return program.Bytes(), nil
-}
-
-// run the given program and parse the output as a model.Package.
-func run(program string) (*model.Package, error) {
-	f, err := os.CreateTemp("", "")
-	if err != nil {
-		return nil, err
-	}
-
-	filename := f.Name()
-	defer os.Remove(filename)
-	if err := f.Close(); err != nil {
-		return nil, err
-	}
-
-	// Run the program.
-	cmd := exec.Command(program, "-output", filename)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	if err := cmd.Run(); err != nil {
-		return nil, err
-	}
-
-	f, err = os.Open(filename)
-	if err != nil {
-		return nil, err
-	}
-
-	// Process output.
-	var pkg model.Package
-	if err := gob.NewDecoder(f).Decode(&pkg); err != nil {
-		return nil, err
-	}
-
-	if err := f.Close(); err != nil {
-		return nil, err
-	}
-
-	return &pkg, nil
-}
-
-// runInDir writes the given program into the given dir, runs it there, and
-// parses the output as a model.Package.
-func runInDir(program []byte, dir string) (*model.Package, error) {
-	// We use TempDir instead of TempFile so we can control the filename.
-	tmpDir, err := os.MkdirTemp(dir, "gomock_reflect_")
-	if err != nil {
-		return nil, err
-	}
-	defer func() {
-		if err := os.RemoveAll(tmpDir); err != nil {
-			log.Printf("failed to remove temp directory: %s", err)
-		}
-	}()
-	const progSource = "prog.go"
-	var progBinary = "prog.bin"
-	if runtime.GOOS == "windows" {
-		// Windows won't execute a program unless it has a ".exe" suffix.
-		progBinary += ".exe"
-	}
-
-	if err := os.WriteFile(filepath.Join(tmpDir, progSource), program, 0600); err != nil {
-		return nil, err
-	}
-
-	cmdArgs := []string{}
-	cmdArgs = append(cmdArgs, "build")
-	if *buildFlags != "" {
-		cmdArgs = append(cmdArgs, strings.Split(*buildFlags, " ")...)
-	}
-	cmdArgs = append(cmdArgs, "-o", progBinary, progSource)
-
-	// Build the program.
-	buf := bytes.NewBuffer(nil)
-	cmd := exec.Command("go", cmdArgs...)
-	cmd.Dir = tmpDir
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = io.MultiWriter(os.Stderr, buf)
-	if err := cmd.Run(); err != nil {
-		sErr := buf.String()
-		if strings.Contains(sErr, `cannot find package "."`) &&
-			strings.Contains(sErr, "go.uber.org/mock/mockgen/model") {
-			fmt.Fprint(os.Stderr, "Please reference the steps in the README to fix this error:\n\thttps://go.uber.org/mock#reflect-vendoring-error.\n")
-			return nil, err
-		}
-		return nil, err
-	}
-
-	return run(filepath.Join(tmpDir, progBinary))
-}
-
-type reflectData struct {
-	ImportPath string
-	Symbols    []string
-}
-
-// This program reflects on an interface value, and prints the
-// gob encoding of a model.Package to standard output.
-// JSON doesn't work because of the model.Type interface.
-var reflectProgram = template.Must(template.New("program").Parse(`
-// Code generated by MockGen. DO NOT EDIT.
-package main
-
-import (
-	"encoding/gob"
-	"flag"
-	"fmt"
-	"os"
-	"path"
-	"reflect"
-
-	"go.uber.org/mock/mockgen/model"
-
-	pkg_ {{printf "%q" .ImportPath}}
-)
-
-var output = flag.String("output", "", "The output file name, or empty to use stdout.")
-
-func main() {
-	flag.Parse()
-
-	its := []struct{
-		sym string
-		typ reflect.Type
-	}{
-		{{range .Symbols}}
-		{ {{printf "%q" .}}, reflect.TypeOf((*pkg_.{{.}})(nil)).Elem()},
-		{{end}}
-	}
-	pkg := &model.Package{
-		// NOTE: This behaves contrary to documented behaviour if the
-		// package name is not the final component of the import path.
-		// The reflect package doesn't expose the package name, though.
-		Name: path.Base({{printf "%q" .ImportPath}}),
-	}
-
-	for _, it := range its {
-		intf, err := model.InterfaceFromInterfaceType(it.typ)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Reflection: %v\n", err)
-			os.Exit(1)
-		}
-		intf.Name = it.sym
-		pkg.Interfaces = append(pkg.Interfaces, intf)
-	}
-
-	outfile := os.Stdout
-	if len(*output) != 0 {
-		var err error
-		outfile, err = os.Create(*output)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "failed to open output file %q", *output)
-		}
-		defer func() {
-			if err := outfile.Close(); err != nil {
-				fmt.Fprintf(os.Stderr, "failed to close output file %q", *output)
-				os.Exit(1)
-			}
-		}()
-	}
-
-	if err := gob.NewEncoder(outfile).Encode(pkg); err != nil {
-		fmt.Fprintf(os.Stderr, "gob encode: %v\n", err)
-		os.Exit(1)
-	}
-}
-`))