X-Git-Url: https://git.josue.xyz/?a=blobdiff_plain;f=.config%2Fcoc%2Fextensions%2Fcoc-go-data%2Ftools%2Fpkg%2Fmod%2Fgolang.org%2Fx%2Ftools%40v0.0.0-20201028153306-37f0764111ff%2Fcmd%2Fguru%2Fimplements.go;fp=.config%2Fcoc%2Fextensions%2Fcoc-go-data%2Ftools%2Fpkg%2Fmod%2Fgolang.org%2Fx%2Ftools%40v0.0.0-20201028153306-37f0764111ff%2Fcmd%2Fguru%2Fimplements.go;h=0000000000000000000000000000000000000000;hb=3ddadb3c98564791f0ac36cb39771d844a63dc91;hp=dbdba041268ba3d7cb8db6c6e7c23148930c165d;hpb=5f797af6612ed10887189b47a1efc2f915586e59;p=dotfiles%2F.git

diff --git a/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201028153306-37f0764111ff/cmd/guru/implements.go b/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201028153306-37f0764111ff/cmd/guru/implements.go
deleted file mode 100644
index dbdba041..00000000
--- a/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201028153306-37f0764111ff/cmd/guru/implements.go
+++ /dev/null
@@ -1,364 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-	"fmt"
-	"go/ast"
-	"go/token"
-	"go/types"
-	"reflect"
-	"sort"
-	"strings"
-
-	"golang.org/x/tools/cmd/guru/serial"
-	"golang.org/x/tools/go/loader"
-	"golang.org/x/tools/go/types/typeutil"
-	"golang.org/x/tools/refactor/importgraph"
-)
-
-// The implements function displays the "implements" relation as it pertains to the
-// selected type.
-// If the selection is a method, 'implements' displays
-// the corresponding methods of the types that would have been reported
-// by an implements query on the receiver type.
-//
-func implements(q *Query) error {
-	lconf := loader.Config{Build: q.Build}
-	allowErrors(&lconf)
-
-	qpkg, err := importQueryPackage(q.Pos, &lconf)
-	if err != nil {
-		return err
-	}
-
-	// Set the packages to search.
-	if len(q.Scope) > 0 {
-		// Inspect all packages in the analysis scope, if specified.
-		if err := setPTAScope(&lconf, q.Scope); err != nil {
-			return err
-		}
-	} else {
-		// Otherwise inspect the forward and reverse
-		// transitive closure of the selected package.
-		// (In theory even this is incomplete.)
-		_, rev, _ := importgraph.Build(q.Build)
-		for path := range rev.Search(qpkg) {
-			lconf.ImportWithTests(path)
-		}
-
-		// TODO(adonovan): for completeness, we should also
-		// type-check and inspect function bodies in all
-		// imported packages.  This would be expensive, but we
-		// could optimize by skipping functions that do not
-		// contain type declarations.  This would require
-		// changing the loader's TypeCheckFuncBodies hook to
-		// provide the []*ast.File.
-	}
-
-	// Load/parse/type-check the program.
-	lprog, err := lconf.Load()
-	if err != nil {
-		return err
-	}
-
-	qpos, err := parseQueryPos(lprog, q.Pos, false)
-	if err != nil {
-		return err
-	}
-
-	// Find the selected type.
-	path, action := findInterestingNode(qpos.info, qpos.path)
-
-	var method *types.Func
-	var T types.Type // selected type (receiver if method != nil)
-
-	switch action {
-	case actionExpr:
-		// method?
-		if id, ok := path[0].(*ast.Ident); ok {
-			if obj, ok := qpos.info.ObjectOf(id).(*types.Func); ok {
-				recv := obj.Type().(*types.Signature).Recv()
-				if recv == nil {
-					return fmt.Errorf("this function is not a method")
-				}
-				method = obj
-				T = recv.Type()
-			}
-		}
-
-		// If not a method, use the expression's type.
-		if T == nil {
-			T = qpos.info.TypeOf(path[0].(ast.Expr))
-		}
-
-	case actionType:
-		T = qpos.info.TypeOf(path[0].(ast.Expr))
-	}
-	if T == nil {
-		return fmt.Errorf("not a type, method, or value")
-	}
-
-	// Find all named types, even local types (which can have
-	// methods due to promotion) and the built-in "error".
-	// We ignore aliases 'type M = N' to avoid duplicate
-	// reporting of the Named type N.
-	var allNamed []*types.Named
-	for _, info := range lprog.AllPackages {
-		for _, obj := range info.Defs {
-			if obj, ok := obj.(*types.TypeName); ok && !isAlias(obj) {
-				if named, ok := obj.Type().(*types.Named); ok {
-					allNamed = append(allNamed, named)
-				}
-			}
-		}
-	}
-	allNamed = append(allNamed, types.Universe.Lookup("error").Type().(*types.Named))
-
-	var msets typeutil.MethodSetCache
-
-	// Test each named type.
-	var to, from, fromPtr []types.Type
-	for _, U := range allNamed {
-		if isInterface(T) {
-			if msets.MethodSet(T).Len() == 0 {
-				continue // empty interface
-			}
-			if isInterface(U) {
-				if msets.MethodSet(U).Len() == 0 {
-					continue // empty interface
-				}
-
-				// T interface, U interface
-				if !types.Identical(T, U) {
-					if types.AssignableTo(U, T) {
-						to = append(to, U)
-					}
-					if types.AssignableTo(T, U) {
-						from = append(from, U)
-					}
-				}
-			} else {
-				// T interface, U concrete
-				if types.AssignableTo(U, T) {
-					to = append(to, U)
-				} else if pU := types.NewPointer(U); types.AssignableTo(pU, T) {
-					to = append(to, pU)
-				}
-			}
-		} else if isInterface(U) {
-			if msets.MethodSet(U).Len() == 0 {
-				continue // empty interface
-			}
-
-			// T concrete, U interface
-			if types.AssignableTo(T, U) {
-				from = append(from, U)
-			} else if pT := types.NewPointer(T); types.AssignableTo(pT, U) {
-				fromPtr = append(fromPtr, U)
-			}
-		}
-	}
-
-	var pos interface{} = qpos
-	if nt, ok := deref(T).(*types.Named); ok {
-		pos = nt.Obj()
-	}
-
-	// Sort types (arbitrarily) to ensure test determinism.
-	sort.Sort(typesByString(to))
-	sort.Sort(typesByString(from))
-	sort.Sort(typesByString(fromPtr))
-
-	var toMethod, fromMethod, fromPtrMethod []*types.Selection // contain nils
-	if method != nil {
-		for _, t := range to {
-			toMethod = append(toMethod,
-				types.NewMethodSet(t).Lookup(method.Pkg(), method.Name()))
-		}
-		for _, t := range from {
-			fromMethod = append(fromMethod,
-				types.NewMethodSet(t).Lookup(method.Pkg(), method.Name()))
-		}
-		for _, t := range fromPtr {
-			fromPtrMethod = append(fromPtrMethod,
-				types.NewMethodSet(t).Lookup(method.Pkg(), method.Name()))
-		}
-	}
-
-	q.Output(lprog.Fset, &implementsResult{
-		qpos, T, pos, to, from, fromPtr, method, toMethod, fromMethod, fromPtrMethod,
-	})
-	return nil
-}
-
-type implementsResult struct {
-	qpos *queryPos
-
-	t       types.Type   // queried type (not necessarily named)
-	pos     interface{}  // pos of t (*types.Name or *QueryPos)
-	to      []types.Type // named or ptr-to-named types assignable to interface T
-	from    []types.Type // named interfaces assignable from T
-	fromPtr []types.Type // named interfaces assignable only from *T
-
-	// if a method was queried:
-	method        *types.Func        // queried method
-	toMethod      []*types.Selection // method of type to[i], if any
-	fromMethod    []*types.Selection // method of type from[i], if any
-	fromPtrMethod []*types.Selection // method of type fromPtrMethod[i], if any
-}
-
-func (r *implementsResult) PrintPlain(printf printfFunc) {
-	relation := "is implemented by"
-
-	meth := func(sel *types.Selection) {
-		if sel != nil {
-			printf(sel.Obj(), "\t%s method (%s).%s",
-				relation, r.qpos.typeString(sel.Recv()), sel.Obj().Name())
-		}
-	}
-
-	if isInterface(r.t) {
-		if types.NewMethodSet(r.t).Len() == 0 { // TODO(adonovan): cache mset
-			printf(r.pos, "empty interface type %s", r.qpos.typeString(r.t))
-			return
-		}
-
-		if r.method == nil {
-			printf(r.pos, "interface type %s", r.qpos.typeString(r.t))
-		} else {
-			printf(r.method, "abstract method %s", r.qpos.objectString(r.method))
-		}
-
-		// Show concrete types (or methods) first; use two passes.
-		for i, sub := range r.to {
-			if !isInterface(sub) {
-				if r.method == nil {
-					printf(deref(sub).(*types.Named).Obj(), "\t%s %s type %s",
-						relation, typeKind(sub), r.qpos.typeString(sub))
-				} else {
-					meth(r.toMethod[i])
-				}
-			}
-		}
-		for i, sub := range r.to {
-			if isInterface(sub) {
-				if r.method == nil {
-					printf(sub.(*types.Named).Obj(), "\t%s %s type %s",
-						relation, typeKind(sub), r.qpos.typeString(sub))
-				} else {
-					meth(r.toMethod[i])
-				}
-			}
-		}
-
-		relation = "implements"
-		for i, super := range r.from {
-			if r.method == nil {
-				printf(super.(*types.Named).Obj(), "\t%s %s",
-					relation, r.qpos.typeString(super))
-			} else {
-				meth(r.fromMethod[i])
-			}
-		}
-	} else {
-		relation = "implements"
-
-		if r.from != nil {
-			if r.method == nil {
-				printf(r.pos, "%s type %s",
-					typeKind(r.t), r.qpos.typeString(r.t))
-			} else {
-				printf(r.method, "concrete method %s",
-					r.qpos.objectString(r.method))
-			}
-			for i, super := range r.from {
-				if r.method == nil {
-					printf(super.(*types.Named).Obj(), "\t%s %s",
-						relation, r.qpos.typeString(super))
-				} else {
-					meth(r.fromMethod[i])
-				}
-			}
-		}
-		if r.fromPtr != nil {
-			if r.method == nil {
-				printf(r.pos, "pointer type *%s", r.qpos.typeString(r.t))
-			} else {
-				// TODO(adonovan): de-dup (C).f and (*C).f implementing (I).f.
-				printf(r.method, "concrete method %s",
-					r.qpos.objectString(r.method))
-			}
-
-			for i, psuper := range r.fromPtr {
-				if r.method == nil {
-					printf(psuper.(*types.Named).Obj(), "\t%s %s",
-						relation, r.qpos.typeString(psuper))
-				} else {
-					meth(r.fromPtrMethod[i])
-				}
-			}
-		} else if r.from == nil {
-			printf(r.pos, "%s type %s implements only interface{}",
-				typeKind(r.t), r.qpos.typeString(r.t))
-		}
-	}
-}
-
-func (r *implementsResult) JSON(fset *token.FileSet) []byte {
-	var method *serial.DescribeMethod
-	if r.method != nil {
-		method = &serial.DescribeMethod{
-			Name: r.qpos.objectString(r.method),
-			Pos:  fset.Position(r.method.Pos()).String(),
-		}
-	}
-	return toJSON(&serial.Implements{
-		T:                       makeImplementsType(r.t, fset),
-		AssignableTo:            makeImplementsTypes(r.to, fset),
-		AssignableFrom:          makeImplementsTypes(r.from, fset),
-		AssignableFromPtr:       makeImplementsTypes(r.fromPtr, fset),
-		AssignableToMethod:      methodsToSerial(r.qpos.info.Pkg, r.toMethod, fset),
-		AssignableFromMethod:    methodsToSerial(r.qpos.info.Pkg, r.fromMethod, fset),
-		AssignableFromPtrMethod: methodsToSerial(r.qpos.info.Pkg, r.fromPtrMethod, fset),
-		Method:                  method,
-	})
-
-}
-
-func makeImplementsTypes(tt []types.Type, fset *token.FileSet) []serial.ImplementsType {
-	var r []serial.ImplementsType
-	for _, t := range tt {
-		r = append(r, makeImplementsType(t, fset))
-	}
-	return r
-}
-
-func makeImplementsType(T types.Type, fset *token.FileSet) serial.ImplementsType {
-	var pos token.Pos
-	if nt, ok := deref(T).(*types.Named); ok { // implementsResult.t may be non-named
-		pos = nt.Obj().Pos()
-	}
-	return serial.ImplementsType{
-		Name: T.String(),
-		Pos:  fset.Position(pos).String(),
-		Kind: typeKind(T),
-	}
-}
-
-// typeKind returns a string describing the underlying kind of type,
-// e.g. "slice", "array", "struct".
-func typeKind(T types.Type) string {
-	s := reflect.TypeOf(T.Underlying()).String()
-	return strings.ToLower(strings.TrimPrefix(s, "*types."))
-}
-
-func isInterface(T types.Type) bool { return types.IsInterface(T) }
-
-type typesByString []types.Type
-
-func (p typesByString) Len() int           { return len(p) }
-func (p typesByString) Less(i, j int) bool { return p[i].String() < p[j].String() }
-func (p typesByString) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }