Giant blob of minor changes

[dotfiles/.git] / .config / coc / extensions / coc-go-data / tools / pkg / mod / golang.org / x / tools@v0.0.0-20201105173854-bc9fc8d8c4bc / internal / lsp / source / completion / snippet.go

diff --git a/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201105173854-bc9fc8d8c4bc/internal/lsp/source/completion/snippet.go b/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201105173854-bc9fc8d8c4bc/internal/lsp/source/completion/snippet.go
new file mode 100644 (file)
index 0000000..4a4288e
--- /dev/null
+++ b/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201105173854-bc9fc8d8c4bc/internal/lsp/source/completion/snippet.go
@@ -0,0 +1,102 @@
+// Copyright 2019 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 completion
+
+import (
+       "go/ast"
+
+       "golang.org/x/tools/internal/lsp/snippet"
+)
+
+// structFieldSnippets calculates the snippet for struct literal field names.
+func (c *completer) structFieldSnippet(cand candidate, label, detail string) *snippet.Builder {
+       if !c.wantStructFieldCompletions() {
+               return nil
+       }
+
+       // If we are in a deep completion then we can't be completing a field
+       // name (e.g. "Foo{f<>}" completing to "Foo{f.Bar}" should not generate
+       // a snippet).
+       if len(cand.path) > 0 {
+               return nil
+       }
+
+       clInfo := c.enclosingCompositeLiteral
+
+       // If we are already in a key-value expression, we don't want a snippet.
+       if clInfo.kv != nil {
+               return nil
+       }
+
+       snip := &snippet.Builder{}
+
+       // A plain snippet turns "Foo{Ba<>" into "Foo{Bar: <>".
+       snip.WriteText(label + ": ")
+       snip.WritePlaceholder(func(b *snippet.Builder) {
+               // A placeholder snippet turns "Foo{Ba<>" into "Foo{Bar: <*int*>".
+               if c.opts.placeholders {
+                       b.WriteText(detail)
+               }
+       })
+
+       fset := c.snapshot.FileSet()
+
+       // If the cursor position is on a different line from the literal's opening brace,
+       // we are in a multiline literal.
+       if fset.Position(c.pos).Line != fset.Position(clInfo.cl.Lbrace).Line {
+               snip.WriteText(",")
+       }
+
+       return snip
+}
+
+// functionCallSnippets calculates the snippet for function calls.
+func (c *completer) functionCallSnippet(name string, params []string) *snippet.Builder {
+       // If there is no suffix then we need to reuse existing call parens
+       // "()" if present. If there is an identifier suffix then we always
+       // need to include "()" since we don't overwrite the suffix.
+       if c.surrounding != nil && c.surrounding.Suffix() == "" && len(c.path) > 1 {
+               // If we are the left side (i.e. "Fun") part of a call expression,
+               // we don't want a snippet since there are already parens present.
+               switch n := c.path[1].(type) {
+               case *ast.CallExpr:
+                       // The Lparen != Rparen check detects fudged CallExprs we
+                       // inserted when fixing the AST. In this case, we do still need
+                       // to insert the calling "()" parens.
+                       if n.Fun == c.path[0] && n.Lparen != n.Rparen {
+                               return nil
+                       }
+               case *ast.SelectorExpr:
+                       if len(c.path) > 2 {
+                               if call, ok := c.path[2].(*ast.CallExpr); ok && call.Fun == c.path[1] && call.Lparen != call.Rparen {
+                                       return nil
+                               }
+                       }
+               }
+       }
+       snip := &snippet.Builder{}
+       snip.WriteText(name + "(")
+
+       if c.opts.placeholders {
+               // A placeholder snippet turns "someFun<>" into "someFunc(<*i int*>, *s string*)".
+               for i, p := range params {
+                       if i > 0 {
+                               snip.WriteText(", ")
+                       }
+                       snip.WritePlaceholder(func(b *snippet.Builder) {
+                               b.WriteText(p)
+                       })
+               }
+       } else {
+               // A plain snippet turns "someFun<>" into "someFunc(<>)".
+               if len(params) > 0 {
+                       snip.WritePlaceholder(nil)
+               }
+       }
+
+       snip.WriteText(")")
+
+       return snip
+}