--- /dev/null
+// Copyright 2018 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 source
+
+import (
+ "context"
+ "go/ast"
+ "go/doc"
+ "go/token"
+ "go/types"
+
+ "golang.org/x/tools/go/ast/astutil"
+ "golang.org/x/tools/internal/event"
+ "golang.org/x/tools/internal/lsp/protocol"
+ errors "golang.org/x/xerrors"
+)
+
+func SignatureHelp(ctx context.Context, snapshot Snapshot, fh FileHandle, pos protocol.Position) (*protocol.SignatureInformation, int, error) {
+ ctx, done := event.Start(ctx, "source.SignatureHelp")
+ defer done()
+
+ pkg, pgf, err := GetParsedFile(ctx, snapshot, fh, NarrowestPackage)
+ if err != nil {
+ return nil, 0, errors.Errorf("getting file for SignatureHelp: %w", err)
+ }
+ spn, err := pgf.Mapper.PointSpan(pos)
+ if err != nil {
+ return nil, 0, err
+ }
+ rng, err := spn.Range(pgf.Mapper.Converter)
+ if err != nil {
+ return nil, 0, err
+ }
+ // Find a call expression surrounding the query position.
+ var callExpr *ast.CallExpr
+ path, _ := astutil.PathEnclosingInterval(pgf.File, rng.Start, rng.Start)
+ if path == nil {
+ return nil, 0, errors.Errorf("cannot find node enclosing position")
+ }
+FindCall:
+ for _, node := range path {
+ switch node := node.(type) {
+ case *ast.CallExpr:
+ if rng.Start >= node.Lparen && rng.Start <= node.Rparen {
+ callExpr = node
+ break FindCall
+ }
+ case *ast.FuncLit, *ast.FuncType:
+ // The user is within an anonymous function,
+ // which may be the parameter to the *ast.CallExpr.
+ // Don't show signature help in this case.
+ return nil, 0, errors.Errorf("no signature help within a function declaration")
+ }
+ }
+ if callExpr == nil || callExpr.Fun == nil {
+ return nil, 0, errors.Errorf("cannot find an enclosing function")
+ }
+
+ qf := Qualifier(pgf.File, pkg.GetTypes(), pkg.GetTypesInfo())
+
+ // Get the object representing the function, if available.
+ // There is no object in certain cases such as calling a function returned by
+ // a function (e.g. "foo()()").
+ var obj types.Object
+ switch t := callExpr.Fun.(type) {
+ case *ast.Ident:
+ obj = pkg.GetTypesInfo().ObjectOf(t)
+ case *ast.SelectorExpr:
+ obj = pkg.GetTypesInfo().ObjectOf(t.Sel)
+ }
+
+ // Handle builtin functions separately.
+ if obj, ok := obj.(*types.Builtin); ok {
+ return builtinSignature(ctx, snapshot, callExpr, obj.Name(), rng.Start)
+ }
+
+ // Get the type information for the function being called.
+ sigType := pkg.GetTypesInfo().TypeOf(callExpr.Fun)
+ if sigType == nil {
+ return nil, 0, errors.Errorf("cannot get type for Fun %[1]T (%[1]v)", callExpr.Fun)
+ }
+
+ sig, _ := sigType.Underlying().(*types.Signature)
+ if sig == nil {
+ return nil, 0, errors.Errorf("cannot find signature for Fun %[1]T (%[1]v)", callExpr.Fun)
+ }
+
+ activeParam := activeParameter(callExpr, sig.Params().Len(), sig.Variadic(), rng.Start)
+
+ var (
+ name string
+ comment *ast.CommentGroup
+ )
+ if obj != nil {
+ node, err := objToDecl(ctx, snapshot, pkg, obj)
+ if err != nil {
+ return nil, 0, err
+ }
+ rng, err := objToMappedRange(snapshot, pkg, obj)
+ if err != nil {
+ return nil, 0, err
+ }
+ decl := Declaration{
+ obj: obj,
+ node: node,
+ }
+ decl.MappedRange = append(decl.MappedRange, rng)
+ d, err := HoverInfo(ctx, pkg, decl.obj, decl.node)
+ if err != nil {
+ return nil, 0, err
+ }
+ name = obj.Name()
+ comment = d.comment
+ } else {
+ name = "func"
+ }
+ s := NewSignature(ctx, snapshot, pkg, sig, comment, qf)
+ paramInfo := make([]protocol.ParameterInformation, 0, len(s.params))
+ for _, p := range s.params {
+ paramInfo = append(paramInfo, protocol.ParameterInformation{Label: p})
+ }
+ return &protocol.SignatureInformation{
+ Label: name + s.Format(),
+ Documentation: doc.Synopsis(s.doc),
+ Parameters: paramInfo,
+ }, activeParam, nil
+}
+
+func builtinSignature(ctx context.Context, snapshot Snapshot, callExpr *ast.CallExpr, name string, pos token.Pos) (*protocol.SignatureInformation, int, error) {
+ sig, err := NewBuiltinSignature(ctx, snapshot, name)
+ if err != nil {
+ return nil, 0, err
+ }
+ paramInfo := make([]protocol.ParameterInformation, 0, len(sig.params))
+ for _, p := range sig.params {
+ paramInfo = append(paramInfo, protocol.ParameterInformation{Label: p})
+ }
+ activeParam := activeParameter(callExpr, len(sig.params), sig.variadic, pos)
+ return &protocol.SignatureInformation{
+ Label: sig.name + sig.Format(),
+ Documentation: doc.Synopsis(sig.doc),
+ Parameters: paramInfo,
+ }, activeParam, nil
+
+}
+
+func activeParameter(callExpr *ast.CallExpr, numParams int, variadic bool, pos token.Pos) (activeParam int) {
+ if len(callExpr.Args) == 0 {
+ return 0
+ }
+ // First, check if the position is even in the range of the arguments.
+ start, end := callExpr.Lparen, callExpr.Rparen
+ if !(start <= pos && pos <= end) {
+ return 0
+ }
+ for _, expr := range callExpr.Args {
+ if start == token.NoPos {
+ start = expr.Pos()
+ }
+ end = expr.End()
+ if start <= pos && pos <= end {
+ break
+ }
+ // Don't advance the active parameter for the last parameter of a variadic function.
+ if !variadic || activeParam < numParams-1 {
+ activeParam++
+ }
+ start = expr.Pos() + 1 // to account for commas
+ }
+ return activeParam
+}
projects / dotfiles / .git / blobdiff