+++ /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 completion provides core functionality for code completion in Go
-// editors and tools.
-package completion
-
-import (
- "context"
- "fmt"
- "go/ast"
- "go/constant"
- "go/scanner"
- "go/token"
- "go/types"
- "math"
- "sort"
- "strconv"
- "strings"
- "sync"
- "time"
- "unicode"
-
- "golang.org/x/tools/go/ast/astutil"
- "golang.org/x/tools/internal/event"
- "golang.org/x/tools/internal/imports"
- "golang.org/x/tools/internal/lsp/fuzzy"
- "golang.org/x/tools/internal/lsp/protocol"
- "golang.org/x/tools/internal/lsp/snippet"
- "golang.org/x/tools/internal/lsp/source"
- errors "golang.org/x/xerrors"
-)
-
-type CompletionItem struct {
- // Label is the primary text the user sees for this completion item.
- Label string
-
- // Detail is supplemental information to present to the user.
- // This often contains the type or return type of the completion item.
- Detail string
-
- // InsertText is the text to insert if this item is selected.
- // Any of the prefix that has already been typed is not trimmed.
- // The insert text does not contain snippets.
- InsertText string
-
- Kind protocol.CompletionItemKind
-
- // An optional array of additional TextEdits that are applied when
- // selecting this completion.
- //
- // Additional text edits should be used to change text unrelated to the current cursor position
- // (for example adding an import statement at the top of the file if the completion item will
- // insert an unqualified type).
- AdditionalTextEdits []protocol.TextEdit
-
- // Depth is how many levels were searched to find this completion.
- // For example when completing "foo<>", "fooBar" is depth 0, and
- // "fooBar.Baz" is depth 1.
- Depth int
-
- // Score is the internal relevance score.
- // A higher score indicates that this completion item is more relevant.
- Score float64
-
- // snippet is the LSP snippet for the completion item. The LSP
- // specification contains details about LSP snippets. For example, a
- // snippet for a function with the following signature:
- //
- // func foo(a, b, c int)
- //
- // would be:
- //
- // foo(${1:a int}, ${2: b int}, ${3: c int})
- //
- // If Placeholders is false in the CompletionOptions, the above
- // snippet would instead be:
- //
- // foo(${1:})
- snippet *snippet.Builder
-
- // Documentation is the documentation for the completion item.
- Documentation string
-
- // obj is the object from which this candidate was derived, if any.
- // obj is for internal use only.
- obj types.Object
-}
-
-// completionOptions holds completion specific configuration.
-type completionOptions struct {
- unimported bool
- documentation bool
- fullDocumentation bool
- placeholders bool
- literal bool
- matcher source.Matcher
- budget time.Duration
-}
-
-// Snippet is a convenience returns the snippet if available, otherwise
-// the InsertText.
-// used for an item, depending on if the callee wants placeholders or not.
-func (i *CompletionItem) Snippet() string {
- if i.snippet != nil {
- return i.snippet.String()
- }
- return i.InsertText
-}
-
-// Scoring constants are used for weighting the relevance of different candidates.
-const (
- // stdScore is the base score for all completion items.
- stdScore float64 = 1.0
-
- // highScore indicates a very relevant completion item.
- highScore float64 = 10.0
-
- // lowScore indicates an irrelevant or not useful completion item.
- lowScore float64 = 0.01
-)
-
-// matcher matches a candidate's label against the user input. The
-// returned score reflects the quality of the match. A score of zero
-// indicates no match, and a score of one means a perfect match.
-type matcher interface {
- Score(candidateLabel string) (score float32)
-}
-
-// prefixMatcher implements case sensitive prefix matching.
-type prefixMatcher string
-
-func (pm prefixMatcher) Score(candidateLabel string) float32 {
- if strings.HasPrefix(candidateLabel, string(pm)) {
- return 1
- }
- return -1
-}
-
-// insensitivePrefixMatcher implements case insensitive prefix matching.
-type insensitivePrefixMatcher string
-
-func (ipm insensitivePrefixMatcher) Score(candidateLabel string) float32 {
- if strings.HasPrefix(strings.ToLower(candidateLabel), string(ipm)) {
- return 1
- }
- return -1
-}
-
-// completer contains the necessary information for a single completion request.
-type completer struct {
- snapshot source.Snapshot
- pkg source.Package
- qf types.Qualifier
- opts *completionOptions
-
- // completionContext contains information about the trigger for this
- // completion request.
- completionContext completionContext
-
- // fh is a handle to the file associated with this completion request.
- fh source.FileHandle
-
- // filename is the name of the file associated with this completion request.
- filename string
-
- // file is the AST of the file associated with this completion request.
- file *ast.File
-
- // pos is the position at which the request was triggered.
- pos token.Pos
-
- // path is the path of AST nodes enclosing the position.
- path []ast.Node
-
- // seen is the map that ensures we do not return duplicate results.
- seen map[types.Object]bool
-
- // items is the list of completion items returned.
- items []CompletionItem
-
- // completionCallbacks is a list of callbacks to collect completions that
- // require expensive operations. This includes operations where we search
- // through the entire module cache.
- completionCallbacks []func(opts *imports.Options) error
-
- // surrounding describes the identifier surrounding the position.
- surrounding *Selection
-
- // inference contains information we've inferred about ideal
- // candidates such as the candidate's type.
- inference candidateInference
-
- // enclosingFunc contains information about the function enclosing
- // the position.
- enclosingFunc *funcInfo
-
- // enclosingCompositeLiteral contains information about the composite literal
- // enclosing the position.
- enclosingCompositeLiteral *compLitInfo
-
- // deepState contains the current state of our deep completion search.
- deepState deepCompletionState
-
- // matcher matches the candidates against the surrounding prefix.
- matcher matcher
-
- // methodSetCache caches the types.NewMethodSet call, which is relatively
- // expensive and can be called many times for the same type while searching
- // for deep completions.
- methodSetCache map[methodSetKey]*types.MethodSet
-
- // mapper converts the positions in the file from which the completion originated.
- mapper *protocol.ColumnMapper
-
- // startTime is when we started processing this completion request. It does
- // not include any time the request spent in the queue.
- startTime time.Time
-}
-
-// funcInfo holds info about a function object.
-type funcInfo struct {
- // sig is the function declaration enclosing the position.
- sig *types.Signature
-
- // body is the function's body.
- body *ast.BlockStmt
-}
-
-type compLitInfo struct {
- // cl is the *ast.CompositeLit enclosing the position.
- cl *ast.CompositeLit
-
- // clType is the type of cl.
- clType types.Type
-
- // kv is the *ast.KeyValueExpr enclosing the position, if any.
- kv *ast.KeyValueExpr
-
- // inKey is true if we are certain the position is in the key side
- // of a key-value pair.
- inKey bool
-
- // maybeInFieldName is true if inKey is false and it is possible
- // we are completing a struct field name. For example,
- // "SomeStruct{<>}" will be inKey=false, but maybeInFieldName=true
- // because we _could_ be completing a field name.
- maybeInFieldName bool
-}
-
-type importInfo struct {
- importPath string
- name string
- pkg source.Package
-}
-
-type methodSetKey struct {
- typ types.Type
- addressable bool
-}
-
-type completionContext struct {
- // triggerCharacter is the character used to trigger completion at current
- // position, if any.
- triggerCharacter string
-
- // triggerKind is information about how a completion was triggered.
- triggerKind protocol.CompletionTriggerKind
-
- // commentCompletion is true if we are completing a comment.
- commentCompletion bool
-
- // packageCompletion is true if we are completing a package name.
- packageCompletion bool
-}
-
-// A Selection represents the cursor position and surrounding identifier.
-type Selection struct {
- content string
- cursor token.Pos
- source.MappedRange
-}
-
-func (p Selection) Content() string {
- return p.content
-}
-
-func (p Selection) Start() token.Pos {
- return p.MappedRange.SpanRange().Start
-}
-
-func (p Selection) End() token.Pos {
- return p.MappedRange.SpanRange().End
-}
-
-func (p Selection) Prefix() string {
- return p.content[:p.cursor-p.SpanRange().Start]
-}
-
-func (p Selection) Suffix() string {
- return p.content[p.cursor-p.SpanRange().Start:]
-}
-
-func (c *completer) setSurrounding(ident *ast.Ident) {
- if c.surrounding != nil {
- return
- }
- if !(ident.Pos() <= c.pos && c.pos <= ident.End()) {
- return
- }
-
- c.surrounding = &Selection{
- content: ident.Name,
- cursor: c.pos,
- // Overwrite the prefix only.
- MappedRange: source.NewMappedRange(c.snapshot.FileSet(), c.mapper, ident.Pos(), ident.End()),
- }
-
- c.setMatcherFromPrefix(c.surrounding.Prefix())
-}
-
-func (c *completer) setMatcherFromPrefix(prefix string) {
- switch c.opts.matcher {
- case source.Fuzzy:
- c.matcher = fuzzy.NewMatcher(prefix)
- case source.CaseSensitive:
- c.matcher = prefixMatcher(prefix)
- default:
- c.matcher = insensitivePrefixMatcher(strings.ToLower(prefix))
- }
-}
-
-func (c *completer) getSurrounding() *Selection {
- if c.surrounding == nil {
- c.surrounding = &Selection{
- content: "",
- cursor: c.pos,
- MappedRange: source.NewMappedRange(c.snapshot.FileSet(), c.mapper, c.pos, c.pos),
- }
- }
- return c.surrounding
-}
-
-// candidate represents a completion candidate.
-type candidate struct {
- // obj is the types.Object to complete to.
- obj types.Object
-
- // score is used to rank candidates.
- score float64
-
- // name is the deep object name path, e.g. "foo.bar"
- name string
-
- // detail is additional information about this item. If not specified,
- // defaults to type string for the object.
- detail string
-
- // path holds the path from the search root (excluding the candidate
- // itself) for a deep candidate.
- path []types.Object
-
- // names tracks the names of objects from search root (excluding the
- // candidate itself) for a deep candidate. This also includes
- // expanded calls for function invocations.
- names []string
-
- // expandFuncCall is true if obj should be invoked in the completion.
- // For example, expandFuncCall=true yields "foo()", expandFuncCall=false yields "foo".
- expandFuncCall bool
-
- // takeAddress is true if the completion should take a pointer to obj.
- // For example, takeAddress=true yields "&foo", takeAddress=false yields "foo".
- takeAddress bool
-
- // addressable is true if a pointer can be taken to the candidate.
- addressable bool
-
- // makePointer is true if the candidate type name T should be made into *T.
- makePointer bool
-
- // dereference is a count of how many times to dereference the candidate obj.
- // For example, dereference=2 turns "foo" into "**foo" when formatting.
- dereference int
-
- // variadic is true if this candidate fills a variadic param and
- // needs "..." appended.
- variadic bool
-
- // imp is the import that needs to be added to this package in order
- // for this candidate to be valid. nil if no import needed.
- imp *importInfo
-}
-
-// ErrIsDefinition is an error that informs the user they got no
-// completions because they tried to complete the name of a new object
-// being defined.
-type ErrIsDefinition struct {
- objStr string
-}
-
-func (e ErrIsDefinition) Error() string {
- msg := "this is a definition"
- if e.objStr != "" {
- msg += " of " + e.objStr
- }
- return msg
-}
-
-// Completion returns a list of possible candidates for completion, given a
-// a file and a position.
-//
-// The selection is computed based on the preceding identifier and can be used by
-// the client to score the quality of the completion. For instance, some clients
-// may tolerate imperfect matches as valid completion results, since users may make typos.
-func Completion(ctx context.Context, snapshot source.Snapshot, fh source.FileHandle, protoPos protocol.Position, protoContext protocol.CompletionContext) ([]CompletionItem, *Selection, error) {
- ctx, done := event.Start(ctx, "completion.Completion")
- defer done()
-
- startTime := time.Now()
-
- pkg, pgf, err := source.GetParsedFile(ctx, snapshot, fh, source.NarrowestPackage)
- if err != nil || pgf.File.Package == token.NoPos {
- // If we can't parse this file or find position for the package
- // keyword, it may be missing a package declaration. Try offering
- // suggestions for the package declaration.
- // Note that this would be the case even if the keyword 'package' is
- // present but no package name exists.
- items, surrounding, innerErr := packageClauseCompletions(ctx, snapshot, fh, protoPos)
- if innerErr != nil {
- // return the error for GetParsedFile since it's more relevant in this situation.
- return nil, nil, errors.Errorf("getting file for Completion: %w (package completions: %v)", err, innerErr)
-
- }
- return items, surrounding, nil
- }
- spn, err := pgf.Mapper.PointSpan(protoPos)
- if err != nil {
- return nil, nil, err
- }
- rng, err := spn.Range(pgf.Mapper.Converter)
- if err != nil {
- return nil, nil, err
- }
- // Completion is based on what precedes the cursor.
- // Find the path to the position before pos.
- path, _ := astutil.PathEnclosingInterval(pgf.File, rng.Start-1, rng.Start-1)
- if path == nil {
- return nil, nil, errors.Errorf("cannot find node enclosing position")
- }
-
- pos := rng.Start
-
- // Check if completion at this position is valid. If not, return early.
- switch n := path[0].(type) {
- case *ast.BasicLit:
- // Skip completion inside literals except for ImportSpec
- if len(path) > 1 {
- if _, ok := path[1].(*ast.ImportSpec); ok {
- break
- }
- }
- return nil, nil, nil
- case *ast.CallExpr:
- if n.Ellipsis.IsValid() && pos > n.Ellipsis && pos <= n.Ellipsis+token.Pos(len("...")) {
- // Don't offer completions inside or directly after "...". For
- // example, don't offer completions at "<>" in "foo(bar...<>").
- return nil, nil, nil
- }
- case *ast.Ident:
- // reject defining identifiers
- if obj, ok := pkg.GetTypesInfo().Defs[n]; ok {
- if v, ok := obj.(*types.Var); ok && v.IsField() && v.Embedded() {
- // An anonymous field is also a reference to a type.
- } else if pgf.File.Name == n {
- // Don't skip completions if Ident is for package name.
- break
- } else {
- objStr := ""
- if obj != nil {
- qual := types.RelativeTo(pkg.GetTypes())
- objStr = types.ObjectString(obj, qual)
- }
- return nil, nil, ErrIsDefinition{objStr: objStr}
- }
- }
- }
-
- opts := snapshot.View().Options()
- c := &completer{
- pkg: pkg,
- snapshot: snapshot,
- qf: source.Qualifier(pgf.File, pkg.GetTypes(), pkg.GetTypesInfo()),
- completionContext: completionContext{
- triggerCharacter: protoContext.TriggerCharacter,
- triggerKind: protoContext.TriggerKind,
- },
- fh: fh,
- filename: fh.URI().Filename(),
- file: pgf.File,
- path: path,
- pos: pos,
- seen: make(map[types.Object]bool),
- enclosingFunc: enclosingFunction(path, pkg.GetTypesInfo()),
- enclosingCompositeLiteral: enclosingCompositeLiteral(path, rng.Start, pkg.GetTypesInfo()),
- deepState: deepCompletionState{
- enabled: opts.DeepCompletion,
- },
- opts: &completionOptions{
- matcher: opts.Matcher,
- unimported: opts.CompleteUnimported,
- documentation: opts.CompletionDocumentation && opts.HoverKind != source.NoDocumentation,
- fullDocumentation: opts.HoverKind == source.FullDocumentation,
- placeholders: opts.UsePlaceholders,
- literal: opts.LiteralCompletions && opts.InsertTextFormat == protocol.SnippetTextFormat,
- budget: opts.CompletionBudget,
- },
- // default to a matcher that always matches
- matcher: prefixMatcher(""),
- methodSetCache: make(map[methodSetKey]*types.MethodSet),
- mapper: pgf.Mapper,
- startTime: startTime,
- }
-
- var cancel context.CancelFunc
- if c.opts.budget == 0 {
- ctx, cancel = context.WithCancel(ctx)
- } else {
- // timeoutDuration is the completion budget remaining. If less than
- // 10ms, set to 10ms
- timeoutDuration := time.Until(c.startTime.Add(c.opts.budget))
- if timeoutDuration < 10*time.Millisecond {
- timeoutDuration = 10 * time.Millisecond
- }
- ctx, cancel = context.WithTimeout(ctx, timeoutDuration)
- }
- defer cancel()
-
- if surrounding := c.containingIdent(pgf.Src); surrounding != nil {
- c.setSurrounding(surrounding)
- }
-
- c.inference = expectedCandidate(ctx, c)
-
- err = c.collectCompletions(ctx)
- if err != nil {
- return nil, nil, err
- }
-
- // Deep search collected candidates and their members for more candidates.
- c.deepSearch(ctx)
- c.deepState.searchQueue = nil
-
- for _, callback := range c.completionCallbacks {
- if err := c.snapshot.RunProcessEnvFunc(ctx, callback); err != nil {
- return nil, nil, err
- }
- }
-
- // Search candidates populated by expensive operations like
- // unimportedMembers etc. for more completion items.
- c.deepSearch(ctx)
-
- // Statement candidates offer an entire statement in certain contexts, as
- // opposed to a single object. Add statement candidates last because they
- // depend on other candidates having already been collected.
- c.addStatementCandidates()
-
- c.sortItems()
- return c.items, c.getSurrounding(), nil
-}
-
-// collectCompletions adds possible completion candidates to either the deep
-// search queue or completion items directly for different completion contexts.
-func (c *completer) collectCompletions(ctx context.Context) error {
- // Inside import blocks, return completions for unimported packages.
- for _, importSpec := range c.file.Imports {
- if !(importSpec.Path.Pos() <= c.pos && c.pos <= importSpec.Path.End()) {
- continue
- }
- return c.populateImportCompletions(ctx, importSpec)
- }
-
- // Inside comments, offer completions for the name of the relevant symbol.
- for _, comment := range c.file.Comments {
- if comment.Pos() < c.pos && c.pos <= comment.End() {
- c.populateCommentCompletions(ctx, comment)
- return nil
- }
- }
-
- // Struct literals are handled entirely separately.
- if c.wantStructFieldCompletions() {
- // If we are definitely completing a struct field name, deep completions
- // don't make sense.
- if c.enclosingCompositeLiteral.inKey {
- c.deepState.enabled = false
- }
- return c.structLiteralFieldName(ctx)
- }
-
- if lt := c.wantLabelCompletion(); lt != labelNone {
- c.labels(lt)
- return nil
- }
-
- if c.emptySwitchStmt() {
- // Empty switch statements only admit "default" and "case" keywords.
- c.addKeywordItems(map[string]bool{}, highScore, CASE, DEFAULT)
- return nil
- }
-
- switch n := c.path[0].(type) {
- case *ast.Ident:
- if c.file.Name == n {
- return c.packageNameCompletions(ctx, c.fh.URI(), n)
- } else if sel, ok := c.path[1].(*ast.SelectorExpr); ok && sel.Sel == n {
- // Is this the Sel part of a selector?
- return c.selector(ctx, sel)
- }
- return c.lexical(ctx)
- // The function name hasn't been typed yet, but the parens are there:
- // recv.‸(arg)
- case *ast.TypeAssertExpr:
- // Create a fake selector expression.
- return c.selector(ctx, &ast.SelectorExpr{X: n.X})
- case *ast.SelectorExpr:
- return c.selector(ctx, n)
- // At the file scope, only keywords are allowed.
- case *ast.BadDecl, *ast.File:
- c.addKeywordCompletions()
- default:
- // fallback to lexical completions
- return c.lexical(ctx)
- }
-
- return nil
-}
-
-// containingIdent returns the *ast.Ident containing pos, if any. It
-// synthesizes an *ast.Ident to allow completion in the face of
-// certain syntax errors.
-func (c *completer) containingIdent(src []byte) *ast.Ident {
- // In the normal case, our leaf AST node is the identifer being completed.
- if ident, ok := c.path[0].(*ast.Ident); ok {
- return ident
- }
-
- pos, tkn, lit := c.scanToken(src)
- if !pos.IsValid() {
- return nil
- }
-
- fakeIdent := &ast.Ident{Name: lit, NamePos: pos}
-
- if _, isBadDecl := c.path[0].(*ast.BadDecl); isBadDecl {
- // You don't get *ast.Idents at the file level, so look for bad
- // decls and use the manually extracted token.
- return fakeIdent
- } else if c.emptySwitchStmt() {
- // Only keywords are allowed in empty switch statements.
- // *ast.Idents are not parsed, so we must use the manually
- // extracted token.
- return fakeIdent
- } else if tkn.IsKeyword() {
- // Otherwise, manually extract the prefix if our containing token
- // is a keyword. This improves completion after an "accidental
- // keyword", e.g. completing to "variance" in "someFunc(var<>)".
- return fakeIdent
- }
-
- return nil
-}
-
-// scanToken scans pgh's contents for the token containing pos.
-func (c *completer) scanToken(contents []byte) (token.Pos, token.Token, string) {
- tok := c.snapshot.FileSet().File(c.pos)
-
- var s scanner.Scanner
- s.Init(tok, contents, nil, 0)
- for {
- tknPos, tkn, lit := s.Scan()
- if tkn == token.EOF || tknPos >= c.pos {
- return token.NoPos, token.ILLEGAL, ""
- }
-
- if len(lit) > 0 && tknPos <= c.pos && c.pos <= tknPos+token.Pos(len(lit)) {
- return tknPos, tkn, lit
- }
- }
-}
-
-func (c *completer) sortItems() {
- sort.SliceStable(c.items, func(i, j int) bool {
- // Sort by score first.
- if c.items[i].Score != c.items[j].Score {
- return c.items[i].Score > c.items[j].Score
- }
-
- // Then sort by label so order stays consistent. This also has the
- // effect of prefering shorter candidates.
- return c.items[i].Label < c.items[j].Label
- })
-}
-
-// emptySwitchStmt reports whether pos is in an empty switch or select
-// statement.
-func (c *completer) emptySwitchStmt() bool {
- block, ok := c.path[0].(*ast.BlockStmt)
- if !ok || len(block.List) > 0 || len(c.path) == 1 {
- return false
- }
-
- switch c.path[1].(type) {
- case *ast.SwitchStmt, *ast.TypeSwitchStmt, *ast.SelectStmt:
- return true
- default:
- return false
- }
-}
-
-// populateImportCompletions yields completions for an import path around the cursor.
-//
-// Completions are suggested at the directory depth of the given import path so
-// that we don't overwhelm the user with a large list of possibilities. As an
-// example, a completion for the prefix "golang" results in "golang.org/".
-// Completions for "golang.org/" yield its subdirectories
-// (i.e. "golang.org/x/"). The user is meant to accept completion suggestions
-// until they reach a complete import path.
-func (c *completer) populateImportCompletions(ctx context.Context, searchImport *ast.ImportSpec) error {
- // deepSearch is not valuable for import completions.
- c.deepState.enabled = false
-
- importPath := searchImport.Path.Value
-
- // Extract the text between the quotes (if any) in an import spec.
- // prefix is the part of import path before the cursor.
- prefixEnd := c.pos - searchImport.Path.Pos()
- prefix := strings.Trim(importPath[:prefixEnd], `"`)
-
- // The number of directories in the import path gives us the depth at
- // which to search.
- depth := len(strings.Split(prefix, "/")) - 1
-
- content := importPath
- start, end := searchImport.Path.Pos(), searchImport.Path.End()
- namePrefix, nameSuffix := `"`, `"`
- // If a starting quote is present, adjust surrounding to either after the
- // cursor or after the first slash (/), except if cursor is at the starting
- // quote. Otherwise we provide a completion including the starting quote.
- if strings.HasPrefix(importPath, `"`) && c.pos > searchImport.Path.Pos() {
- content = content[1:]
- start++
- if depth > 0 {
- // Adjust textEdit start to replacement range. For ex: if current
- // path was "golang.or/x/to<>ols/internal/", where <> is the cursor
- // position, start of the replacement range would be after
- // "golang.org/x/".
- path := strings.SplitAfter(prefix, "/")
- numChars := len(strings.Join(path[:len(path)-1], ""))
- content = content[numChars:]
- start += token.Pos(numChars)
- }
- namePrefix = ""
- }
-
- // We won't provide an ending quote if one is already present, except if
- // cursor is after the ending quote but still in import spec. This is
- // because cursor has to be in our textEdit range.
- if strings.HasSuffix(importPath, `"`) && c.pos < searchImport.Path.End() {
- end--
- content = content[:len(content)-1]
- nameSuffix = ""
- }
-
- c.surrounding = &Selection{
- content: content,
- cursor: c.pos,
- MappedRange: source.NewMappedRange(c.snapshot.FileSet(), c.mapper, start, end),
- }
-
- seenImports := make(map[string]struct{})
- for _, importSpec := range c.file.Imports {
- if importSpec.Path.Value == importPath {
- continue
- }
- seenImportPath, err := strconv.Unquote(importSpec.Path.Value)
- if err != nil {
- return err
- }
- seenImports[seenImportPath] = struct{}{}
- }
-
- var mu sync.Mutex // guard c.items locally, since searchImports is called in parallel
- seen := make(map[string]struct{})
- searchImports := func(pkg imports.ImportFix) {
- path := pkg.StmtInfo.ImportPath
- if _, ok := seenImports[path]; ok {
- return
- }
-
- // Any package path containing fewer directories than the search
- // prefix is not a match.
- pkgDirList := strings.Split(path, "/")
- if len(pkgDirList) < depth+1 {
- return
- }
- pkgToConsider := strings.Join(pkgDirList[:depth+1], "/")
-
- name := pkgDirList[depth]
- // if we're adding an opening quote to completion too, set name to full
- // package path since we'll need to overwrite that range.
- if namePrefix == `"` {
- name = pkgToConsider
- }
-
- score := pkg.Relevance
- if len(pkgDirList)-1 == depth {
- score *= highScore
- } else {
- // For incomplete package paths, add a terminal slash to indicate that the
- // user should keep triggering completions.
- name += "/"
- pkgToConsider += "/"
- }
-
- if _, ok := seen[pkgToConsider]; ok {
- return
- }
- seen[pkgToConsider] = struct{}{}
-
- mu.Lock()
- defer mu.Unlock()
-
- name = namePrefix + name + nameSuffix
- obj := types.NewPkgName(0, nil, name, types.NewPackage(pkgToConsider, name))
- c.deepState.enqueue(candidate{
- obj: obj,
- detail: fmt.Sprintf("%q", pkgToConsider),
- score: score,
- })
- }
-
- c.completionCallbacks = append(c.completionCallbacks, func(opts *imports.Options) error {
- return imports.GetImportPaths(ctx, searchImports, prefix, c.filename, c.pkg.GetTypes().Name(), opts.Env)
- })
- return nil
-}
-
-// populateCommentCompletions yields completions for comments preceding or in declarations.
-func (c *completer) populateCommentCompletions(ctx context.Context, comment *ast.CommentGroup) {
- // If the completion was triggered by a period, ignore it. These types of
- // completions will not be useful in comments.
- if c.completionContext.triggerCharacter == "." {
- return
- }
-
- // Using the comment position find the line after
- file := c.snapshot.FileSet().File(comment.End())
- if file == nil {
- return
- }
-
- // Deep completion doesn't work properly in comments since we don't
- // have a type object to complete further.
- c.deepState.enabled = false
- c.completionContext.commentCompletion = true
-
- // Documentation isn't useful in comments, since it might end up being the
- // comment itself.
- c.opts.documentation = false
-
- commentLine := file.Line(comment.End())
-
- // comment is valid, set surrounding as word boundaries around cursor
- c.setSurroundingForComment(comment)
-
- // Using the next line pos, grab and parse the exported symbol on that line
- for _, n := range c.file.Decls {
- declLine := file.Line(n.Pos())
- // if the comment is not in, directly above or on the same line as a declaration
- if declLine != commentLine && declLine != commentLine+1 &&
- !(n.Pos() <= comment.Pos() && comment.End() <= n.End()) {
- continue
- }
- switch node := n.(type) {
- // handle const, vars, and types
- case *ast.GenDecl:
- for _, spec := range node.Specs {
- switch spec := spec.(type) {
- case *ast.ValueSpec:
- for _, name := range spec.Names {
- if name.String() == "_" {
- continue
- }
- obj := c.pkg.GetTypesInfo().ObjectOf(name)
- c.deepState.enqueue(candidate{obj: obj, score: stdScore})
- }
- case *ast.TypeSpec:
- // add TypeSpec fields to completion
- switch typeNode := spec.Type.(type) {
- case *ast.StructType:
- c.addFieldItems(ctx, typeNode.Fields)
- case *ast.FuncType:
- c.addFieldItems(ctx, typeNode.Params)
- c.addFieldItems(ctx, typeNode.Results)
- case *ast.InterfaceType:
- c.addFieldItems(ctx, typeNode.Methods)
- }
-
- if spec.Name.String() == "_" {
- continue
- }
-
- obj := c.pkg.GetTypesInfo().ObjectOf(spec.Name)
- // Type name should get a higher score than fields but not highScore by default
- // since field near a comment cursor gets a highScore
- score := stdScore * 1.1
- // If type declaration is on the line after comment, give it a highScore.
- if declLine == commentLine+1 {
- score = highScore
- }
-
- c.deepState.enqueue(candidate{obj: obj, score: score})
- }
- }
- // handle functions
- case *ast.FuncDecl:
- c.addFieldItems(ctx, node.Recv)
- c.addFieldItems(ctx, node.Type.Params)
- c.addFieldItems(ctx, node.Type.Results)
-
- // collect receiver struct fields
- if node.Recv != nil {
- for _, fields := range node.Recv.List {
- for _, name := range fields.Names {
- obj := c.pkg.GetTypesInfo().ObjectOf(name)
- if obj == nil {
- continue
- }
-
- recvType := obj.Type().Underlying()
- if ptr, ok := recvType.(*types.Pointer); ok {
- recvType = ptr.Elem()
- }
- recvStruct, ok := recvType.Underlying().(*types.Struct)
- if !ok {
- continue
- }
- for i := 0; i < recvStruct.NumFields(); i++ {
- field := recvStruct.Field(i)
- c.deepState.enqueue(candidate{obj: field, score: lowScore})
- }
- }
- }
- }
-
- if node.Name.String() == "_" {
- continue
- }
-
- obj := c.pkg.GetTypesInfo().ObjectOf(node.Name)
- if obj == nil || obj.Pkg() != nil && obj.Pkg() != c.pkg.GetTypes() {
- continue
- }
-
- c.deepState.enqueue(candidate{obj: obj, score: highScore})
- }
- }
-}
-
-// sets word boundaries surrounding a cursor for a comment
-func (c *completer) setSurroundingForComment(comments *ast.CommentGroup) {
- var cursorComment *ast.Comment
- for _, comment := range comments.List {
- if c.pos >= comment.Pos() && c.pos <= comment.End() {
- cursorComment = comment
- break
- }
- }
- // if cursor isn't in the comment
- if cursorComment == nil {
- return
- }
-
- // index of cursor in comment text
- cursorOffset := int(c.pos - cursorComment.Pos())
- start, end := cursorOffset, cursorOffset
- for start > 0 && isValidIdentifierChar(cursorComment.Text[start-1]) {
- start--
- }
- for end < len(cursorComment.Text) && isValidIdentifierChar(cursorComment.Text[end]) {
- end++
- }
-
- c.surrounding = &Selection{
- content: cursorComment.Text[start:end],
- cursor: c.pos,
- MappedRange: source.NewMappedRange(c.snapshot.FileSet(), c.mapper,
- token.Pos(int(cursorComment.Slash)+start), token.Pos(int(cursorComment.Slash)+end)),
- }
- c.setMatcherFromPrefix(c.surrounding.Prefix())
-}
-
-// isValidIdentifierChar returns true if a byte is a valid go identifier character
-// i.e unicode letter or digit or undescore
-func isValidIdentifierChar(char byte) bool {
- charRune := rune(char)
- return unicode.In(charRune, unicode.Letter, unicode.Digit) || char == '_'
-}
-
-// adds struct fields, interface methods, function declaration fields to completion
-func (c *completer) addFieldItems(ctx context.Context, fields *ast.FieldList) {
- if fields == nil {
- return
- }
-
- cursor := c.surrounding.cursor
- for _, field := range fields.List {
- for _, name := range field.Names {
- if name.String() == "_" {
- continue
- }
- obj := c.pkg.GetTypesInfo().ObjectOf(name)
- if obj == nil {
- continue
- }
-
- // if we're in a field comment/doc, score that field as more relevant
- score := stdScore
- if field.Comment != nil && field.Comment.Pos() <= cursor && cursor <= field.Comment.End() {
- score = highScore
- } else if field.Doc != nil && field.Doc.Pos() <= cursor && cursor <= field.Doc.End() {
- score = highScore
- }
-
- c.deepState.enqueue(candidate{obj: obj, score: score})
- }
- }
-}
-
-func (c *completer) wantStructFieldCompletions() bool {
- clInfo := c.enclosingCompositeLiteral
- if clInfo == nil {
- return false
- }
-
- return clInfo.isStruct() && (clInfo.inKey || clInfo.maybeInFieldName)
-}
-
-func (c *completer) wantTypeName() bool {
- return !c.completionContext.commentCompletion && c.inference.typeName.wantTypeName
-}
-
-// See https://golang.org/issue/36001. Unimported completions are expensive.
-const (
- maxUnimportedPackageNames = 5
- unimportedMemberTarget = 100
-)
-
-// selector finds completions for the specified selector expression.
-func (c *completer) selector(ctx context.Context, sel *ast.SelectorExpr) error {
- c.inference.objChain = objChain(c.pkg.GetTypesInfo(), sel.X)
-
- // Is sel a qualified identifier?
- if id, ok := sel.X.(*ast.Ident); ok {
- if pkgName, ok := c.pkg.GetTypesInfo().Uses[id].(*types.PkgName); ok {
- candidates := c.packageMembers(pkgName.Imported(), stdScore, nil)
- for _, cand := range candidates {
- c.deepState.enqueue(cand)
- }
- return nil
- }
- }
-
- // Invariant: sel is a true selector.
- tv, ok := c.pkg.GetTypesInfo().Types[sel.X]
- if ok {
- candidates := c.methodsAndFields(tv.Type, tv.Addressable(), nil)
- for _, cand := range candidates {
- c.deepState.enqueue(cand)
- }
- return nil
- }
-
- // Try unimported packages.
- if id, ok := sel.X.(*ast.Ident); ok && c.opts.unimported {
- if err := c.unimportedMembers(ctx, id); err != nil {
- return err
- }
- }
- return nil
-}
-
-func (c *completer) unimportedMembers(ctx context.Context, id *ast.Ident) error {
- // Try loaded packages first. They're relevant, fast, and fully typed.
- known, err := c.snapshot.CachedImportPaths(ctx)
- if err != nil {
- return err
- }
-
- var paths []string
- for path, pkg := range known {
- if pkg.GetTypes().Name() != id.Name {
- continue
- }
- paths = append(paths, path)
- }
-
- var relevances map[string]float64
- if len(paths) != 0 {
- if err := c.snapshot.RunProcessEnvFunc(ctx, func(opts *imports.Options) error {
- var err error
- relevances, err = imports.ScoreImportPaths(ctx, opts.Env, paths)
- return err
- }); err != nil {
- return err
- }
- }
- sort.Slice(paths, func(i, j int) bool {
- return relevances[paths[i]] > relevances[paths[j]]
- })
-
- for _, path := range paths {
- pkg := known[path]
- if pkg.GetTypes().Name() != id.Name {
- continue
- }
- imp := &importInfo{
- importPath: path,
- pkg: pkg,
- }
- if imports.ImportPathToAssumedName(path) != pkg.GetTypes().Name() {
- imp.name = pkg.GetTypes().Name()
- }
- candidates := c.packageMembers(pkg.GetTypes(), unimportedScore(relevances[path]), imp)
- for _, cand := range candidates {
- c.deepState.enqueue(cand)
- }
- if len(c.items) >= unimportedMemberTarget {
- return nil
- }
- }
-
- ctx, cancel := context.WithCancel(ctx)
-
- var mu sync.Mutex
- add := func(pkgExport imports.PackageExport) {
- mu.Lock()
- defer mu.Unlock()
- if _, ok := known[pkgExport.Fix.StmtInfo.ImportPath]; ok {
- return // We got this one above.
- }
-
- // Continue with untyped proposals.
- pkg := types.NewPackage(pkgExport.Fix.StmtInfo.ImportPath, pkgExport.Fix.IdentName)
- for _, export := range pkgExport.Exports {
- score := unimportedScore(pkgExport.Fix.Relevance)
- c.deepState.enqueue(candidate{
- obj: types.NewVar(0, pkg, export, nil),
- score: score,
- imp: &importInfo{
- importPath: pkgExport.Fix.StmtInfo.ImportPath,
- name: pkgExport.Fix.StmtInfo.Name,
- },
- })
- }
- if len(c.items) >= unimportedMemberTarget {
- cancel()
- }
- }
-
- c.completionCallbacks = append(c.completionCallbacks, func(opts *imports.Options) error {
- defer cancel()
- return imports.GetPackageExports(ctx, add, id.Name, c.filename, c.pkg.GetTypes().Name(), opts.Env)
- })
- return nil
-}
-
-// unimportedScore returns a score for an unimported package that is generally
-// lower than other candidates.
-func unimportedScore(relevance float64) float64 {
- return (stdScore + .1*relevance) / 2
-}
-
-func (c *completer) packageMembers(pkg *types.Package, score float64, imp *importInfo) []candidate {
- var candidates []candidate
- scope := pkg.Scope()
- for _, name := range scope.Names() {
- obj := scope.Lookup(name)
- candidates = append(candidates, candidate{
- obj: obj,
- score: score,
- imp: imp,
- addressable: isVar(obj),
- })
- }
- return candidates
-}
-
-func (c *completer) methodsAndFields(typ types.Type, addressable bool, imp *importInfo) []candidate {
- mset := c.methodSetCache[methodSetKey{typ, addressable}]
- if mset == nil {
- if addressable && !types.IsInterface(typ) && !isPointer(typ) {
- // Add methods of *T, which includes methods with receiver T.
- mset = types.NewMethodSet(types.NewPointer(typ))
- } else {
- // Add methods of T.
- mset = types.NewMethodSet(typ)
- }
- c.methodSetCache[methodSetKey{typ, addressable}] = mset
- }
-
- var candidates []candidate
- for i := 0; i < mset.Len(); i++ {
- candidates = append(candidates, candidate{
- obj: mset.At(i).Obj(),
- score: stdScore,
- imp: imp,
- addressable: addressable || isPointer(typ),
- })
- }
-
- // Add fields of T.
- eachField(typ, func(v *types.Var) {
- candidates = append(candidates, candidate{
- obj: v,
- score: stdScore - 0.01,
- imp: imp,
- addressable: addressable || isPointer(typ),
- })
- })
-
- return candidates
-}
-
-// lexical finds completions in the lexical environment.
-func (c *completer) lexical(ctx context.Context) error {
- scopes := source.CollectScopes(c.pkg.GetTypesInfo(), c.path, c.pos)
- scopes = append(scopes, c.pkg.GetTypes().Scope(), types.Universe)
-
- var (
- builtinIota = types.Universe.Lookup("iota")
- builtinNil = types.Universe.Lookup("nil")
- )
-
- // Track seen variables to avoid showing completions for shadowed variables.
- // This works since we look at scopes from innermost to outermost.
- seen := make(map[string]struct{})
-
- // Process scopes innermost first.
- for i, scope := range scopes {
- if scope == nil {
- continue
- }
-
- Names:
- for _, name := range scope.Names() {
- declScope, obj := scope.LookupParent(name, c.pos)
- if declScope != scope {
- continue // Name was declared in some enclosing scope, or not at all.
- }
-
- // If obj's type is invalid, find the AST node that defines the lexical block
- // containing the declaration of obj. Don't resolve types for packages.
- if !isPkgName(obj) && !typeIsValid(obj.Type()) {
- // Match the scope to its ast.Node. If the scope is the package scope,
- // use the *ast.File as the starting node.
- var node ast.Node
- if i < len(c.path) {
- node = c.path[i]
- } else if i == len(c.path) { // use the *ast.File for package scope
- node = c.path[i-1]
- }
- if node != nil {
- if resolved := resolveInvalid(c.snapshot.FileSet(), obj, node, c.pkg.GetTypesInfo()); resolved != nil {
- obj = resolved
- }
- }
- }
-
- // Don't use LHS of value spec in RHS.
- if vs := enclosingValueSpec(c.path); vs != nil {
- for _, ident := range vs.Names {
- if obj.Pos() == ident.Pos() {
- continue Names
- }
- }
- }
-
- // Don't suggest "iota" outside of const decls.
- if obj == builtinIota && !c.inConstDecl() {
- continue
- }
-
- // Rank outer scopes lower than inner.
- score := stdScore * math.Pow(.99, float64(i))
-
- // Dowrank "nil" a bit so it is ranked below more interesting candidates.
- if obj == builtinNil {
- score /= 2
- }
-
- // If we haven't already added a candidate for an object with this name.
- if _, ok := seen[obj.Name()]; !ok {
- seen[obj.Name()] = struct{}{}
- c.deepState.enqueue(candidate{
- obj: obj,
- score: score,
- addressable: isVar(obj),
- })
- }
- }
- }
-
- if c.inference.objType != nil {
- if named, _ := source.Deref(c.inference.objType).(*types.Named); named != nil {
- // If we expected a named type, check the type's package for
- // completion items. This is useful when the current file hasn't
- // imported the type's package yet.
-
- if named.Obj() != nil && named.Obj().Pkg() != nil {
- pkg := named.Obj().Pkg()
-
- // Make sure the package name isn't already in use by another
- // object, and that this file doesn't import the package yet.
- if _, ok := seen[pkg.Name()]; !ok && pkg != c.pkg.GetTypes() && !alreadyImports(c.file, pkg.Path()) {
- seen[pkg.Name()] = struct{}{}
- obj := types.NewPkgName(0, nil, pkg.Name(), pkg)
- imp := &importInfo{
- importPath: pkg.Path(),
- }
- if imports.ImportPathToAssumedName(pkg.Path()) != pkg.Name() {
- imp.name = pkg.Name()
- }
- c.deepState.enqueue(candidate{
- obj: obj,
- score: stdScore,
- imp: imp,
- })
- }
- }
- }
- }
-
- if c.opts.unimported {
- if err := c.unimportedPackages(ctx, seen); err != nil {
- return err
- }
- }
-
- if t := c.inference.objType; t != nil {
- t = source.Deref(t)
-
- // If we have an expected type and it is _not_ a named type,
- // handle it specially. Non-named types like "[]int" will never be
- // considered via a lexical search, so we need to directly inject
- // them.
- if _, named := t.(*types.Named); !named {
- // If our expected type is "[]int", this will add a literal
- // candidate of "[]int{}".
- c.literal(ctx, t, nil)
-
- if _, isBasic := t.(*types.Basic); !isBasic {
- // If we expect a non-basic type name (e.g. "[]int"), hack up
- // a named type whose name is literally "[]int". This allows
- // us to reuse our object based completion machinery.
- fakeNamedType := candidate{
- obj: types.NewTypeName(token.NoPos, nil, types.TypeString(t, c.qf), t),
- score: stdScore,
- }
- // Make sure the type name matches before considering
- // candidate. This cuts down on useless candidates.
- if c.matchingTypeName(&fakeNamedType) {
- c.deepState.enqueue(fakeNamedType)
- }
- }
- }
- }
-
- // Add keyword completion items appropriate in the current context.
- c.addKeywordCompletions()
-
- return nil
-}
-
-func (c *completer) unimportedPackages(ctx context.Context, seen map[string]struct{}) error {
- var prefix string
- if c.surrounding != nil {
- prefix = c.surrounding.Prefix()
- }
- count := 0
-
- known, err := c.snapshot.CachedImportPaths(ctx)
- if err != nil {
- return err
- }
- var paths []string
- for path, pkg := range known {
- if !strings.HasPrefix(pkg.GetTypes().Name(), prefix) {
- continue
- }
- paths = append(paths, path)
- }
-
- var relevances map[string]float64
- if len(paths) != 0 {
- if err := c.snapshot.RunProcessEnvFunc(ctx, func(opts *imports.Options) error {
- var err error
- relevances, err = imports.ScoreImportPaths(ctx, opts.Env, paths)
- return err
- }); err != nil {
- return err
- }
- }
- sort.Slice(paths, func(i, j int) bool {
- return relevances[paths[i]] > relevances[paths[j]]
- })
-
- for _, path := range paths {
- pkg := known[path]
- if _, ok := seen[pkg.GetTypes().Name()]; ok {
- continue
- }
- imp := &importInfo{
- importPath: path,
- pkg: pkg,
- }
- if imports.ImportPathToAssumedName(path) != pkg.GetTypes().Name() {
- imp.name = pkg.GetTypes().Name()
- }
- if count >= maxUnimportedPackageNames {
- return nil
- }
- c.deepState.enqueue(candidate{
- obj: types.NewPkgName(0, nil, pkg.GetTypes().Name(), pkg.GetTypes()),
- score: unimportedScore(relevances[path]),
- imp: imp,
- })
- count++
- }
-
- ctx, cancel := context.WithCancel(ctx)
-
- var mu sync.Mutex
- add := func(pkg imports.ImportFix) {
- mu.Lock()
- defer mu.Unlock()
- if _, ok := seen[pkg.IdentName]; ok {
- return
- }
- if _, ok := relevances[pkg.StmtInfo.ImportPath]; ok {
- return
- }
-
- if count >= maxUnimportedPackageNames {
- cancel()
- return
- }
-
- // Do not add the unimported packages to seen, since we can have
- // multiple packages of the same name as completion suggestions, since
- // only one will be chosen.
- obj := types.NewPkgName(0, nil, pkg.IdentName, types.NewPackage(pkg.StmtInfo.ImportPath, pkg.IdentName))
- c.deepState.enqueue(candidate{
- obj: obj,
- score: unimportedScore(pkg.Relevance),
- imp: &importInfo{
- importPath: pkg.StmtInfo.ImportPath,
- name: pkg.StmtInfo.Name,
- },
- })
- count++
- }
- c.completionCallbacks = append(c.completionCallbacks, func(opts *imports.Options) error {
- defer cancel()
- return imports.GetAllCandidates(ctx, add, prefix, c.filename, c.pkg.GetTypes().Name(), opts.Env)
- })
- return nil
-}
-
-// alreadyImports reports whether f has an import with the specified path.
-func alreadyImports(f *ast.File, path string) bool {
- for _, s := range f.Imports {
- if source.ImportPath(s) == path {
- return true
- }
- }
- return false
-}
-
-func (c *completer) inConstDecl() bool {
- for _, n := range c.path {
- if decl, ok := n.(*ast.GenDecl); ok && decl.Tok == token.CONST {
- return true
- }
- }
- return false
-}
-
-// structLiteralFieldName finds completions for struct field names inside a struct literal.
-func (c *completer) structLiteralFieldName(ctx context.Context) error {
- clInfo := c.enclosingCompositeLiteral
-
- // Mark fields of the composite literal that have already been set,
- // except for the current field.
- addedFields := make(map[*types.Var]bool)
- for _, el := range clInfo.cl.Elts {
- if kvExpr, ok := el.(*ast.KeyValueExpr); ok {
- if clInfo.kv == kvExpr {
- continue
- }
-
- if key, ok := kvExpr.Key.(*ast.Ident); ok {
- if used, ok := c.pkg.GetTypesInfo().Uses[key]; ok {
- if usedVar, ok := used.(*types.Var); ok {
- addedFields[usedVar] = true
- }
- }
- }
- }
- }
-
- switch t := clInfo.clType.(type) {
- case *types.Struct:
- for i := 0; i < t.NumFields(); i++ {
- field := t.Field(i)
- if !addedFields[field] {
- c.deepState.enqueue(candidate{
- obj: field,
- score: highScore,
- })
- }
- }
-
- // Add lexical completions if we aren't certain we are in the key part of a
- // key-value pair.
- if clInfo.maybeInFieldName {
- return c.lexical(ctx)
- }
- default:
- return c.lexical(ctx)
- }
-
- return nil
-}
-
-func (cl *compLitInfo) isStruct() bool {
- _, ok := cl.clType.(*types.Struct)
- return ok
-}
-
-// enclosingCompositeLiteral returns information about the composite literal enclosing the
-// position.
-func enclosingCompositeLiteral(path []ast.Node, pos token.Pos, info *types.Info) *compLitInfo {
- for _, n := range path {
- switch n := n.(type) {
- case *ast.CompositeLit:
- // The enclosing node will be a composite literal if the user has just
- // opened the curly brace (e.g. &x{<>) or the completion request is triggered
- // from an already completed composite literal expression (e.g. &x{foo: 1, <>})
- //
- // The position is not part of the composite literal unless it falls within the
- // curly braces (e.g. "foo.Foo<>Struct{}").
- if !(n.Lbrace < pos && pos <= n.Rbrace) {
- // Keep searching since we may yet be inside a composite literal.
- // For example "Foo{B: Ba<>{}}".
- break
- }
-
- tv, ok := info.Types[n]
- if !ok {
- return nil
- }
-
- clInfo := compLitInfo{
- cl: n,
- clType: source.Deref(tv.Type).Underlying(),
- }
-
- var (
- expr ast.Expr
- hasKeys bool
- )
- for _, el := range n.Elts {
- // Remember the expression that the position falls in, if any.
- if el.Pos() <= pos && pos <= el.End() {
- expr = el
- }
-
- if kv, ok := el.(*ast.KeyValueExpr); ok {
- hasKeys = true
- // If expr == el then we know the position falls in this expression,
- // so also record kv as the enclosing *ast.KeyValueExpr.
- if expr == el {
- clInfo.kv = kv
- break
- }
- }
- }
-
- if clInfo.kv != nil {
- // If in a *ast.KeyValueExpr, we know we are in the key if the position
- // is to the left of the colon (e.g. "Foo{F<>: V}".
- clInfo.inKey = pos <= clInfo.kv.Colon
- } else if hasKeys {
- // If we aren't in a *ast.KeyValueExpr but the composite literal has
- // other *ast.KeyValueExprs, we must be on the key side of a new
- // *ast.KeyValueExpr (e.g. "Foo{F: V, <>}").
- clInfo.inKey = true
- } else {
- switch clInfo.clType.(type) {
- case *types.Struct:
- if len(n.Elts) == 0 {
- // If the struct literal is empty, next could be a struct field
- // name or an expression (e.g. "Foo{<>}" could become "Foo{F:}"
- // or "Foo{someVar}").
- clInfo.maybeInFieldName = true
- } else if len(n.Elts) == 1 {
- // If there is one expression and the position is in that expression
- // and the expression is an identifier, we may be writing a field
- // name or an expression (e.g. "Foo{F<>}").
- _, clInfo.maybeInFieldName = expr.(*ast.Ident)
- }
- case *types.Map:
- // If we aren't in a *ast.KeyValueExpr we must be adding a new key
- // to the map.
- clInfo.inKey = true
- }
- }
-
- return &clInfo
- default:
- if breaksExpectedTypeInference(n, pos) {
- return nil
- }
- }
- }
-
- return nil
-}
-
-// enclosingFunction returns the signature and body of the function
-// enclosing the given position.
-func enclosingFunction(path []ast.Node, info *types.Info) *funcInfo {
- for _, node := range path {
- switch t := node.(type) {
- case *ast.FuncDecl:
- if obj, ok := info.Defs[t.Name]; ok {
- return &funcInfo{
- sig: obj.Type().(*types.Signature),
- body: t.Body,
- }
- }
- case *ast.FuncLit:
- if typ, ok := info.Types[t]; ok {
- return &funcInfo{
- sig: typ.Type.(*types.Signature),
- body: t.Body,
- }
- }
- }
- }
- return nil
-}
-
-func (c *completer) expectedCompositeLiteralType() types.Type {
- clInfo := c.enclosingCompositeLiteral
- switch t := clInfo.clType.(type) {
- case *types.Slice:
- if clInfo.inKey {
- return types.Typ[types.Int]
- }
- return t.Elem()
- case *types.Array:
- if clInfo.inKey {
- return types.Typ[types.Int]
- }
- return t.Elem()
- case *types.Map:
- if clInfo.inKey {
- return t.Key()
- }
- return t.Elem()
- case *types.Struct:
- // If we are completing a key (i.e. field name), there is no expected type.
- if clInfo.inKey {
- return nil
- }
-
- // If we are in a key-value pair, but not in the key, then we must be on the
- // value side. The expected type of the value will be determined from the key.
- if clInfo.kv != nil {
- if key, ok := clInfo.kv.Key.(*ast.Ident); ok {
- for i := 0; i < t.NumFields(); i++ {
- if field := t.Field(i); field.Name() == key.Name {
- return field.Type()
- }
- }
- }
- } else {
- // If we aren't in a key-value pair and aren't in the key, we must be using
- // implicit field names.
-
- // The order of the literal fields must match the order in the struct definition.
- // Find the element that the position belongs to and suggest that field's type.
- if i := exprAtPos(c.pos, clInfo.cl.Elts); i < t.NumFields() {
- return t.Field(i).Type()
- }
- }
- }
- return nil
-}
-
-// typeModifier represents an operator that changes the expected type.
-type typeModifier struct {
- mod typeMod
- arrayLen int64
-}
-
-type typeMod int
-
-const (
- dereference typeMod = iota // pointer indirection: "*"
- reference // adds level of pointer: "&" for values, "*" for type names
- chanRead // channel read operator ("<-")
- slice // make a slice type ("[]" in "[]int")
- array // make an array type ("[2]" in "[2]int")
-)
-
-type objKind int
-
-const (
- kindAny objKind = 0
- kindArray objKind = 1 << iota
- kindSlice
- kindChan
- kindMap
- kindStruct
- kindString
- kindInt
- kindBool
- kindBytes
- kindPtr
- kindFloat
- kindComplex
- kindError
- kindStringer
- kindFunc
-)
-
-// penalizedObj represents an object that should be disfavored as a
-// completion candidate.
-type penalizedObj struct {
- // objChain is the full "chain", e.g. "foo.bar().baz" becomes
- // []types.Object{foo, bar, baz}.
- objChain []types.Object
- // penalty is score penalty in the range (0, 1).
- penalty float64
-}
-
-// candidateInference holds information we have inferred about a type that can be
-// used at the current position.
-type candidateInference struct {
- // objType is the desired type of an object used at the query position.
- objType types.Type
-
- // objKind is a mask of expected kinds of types such as "map", "slice", etc.
- objKind objKind
-
- // variadic is true if we are completing the initial variadic
- // parameter. For example:
- // append([]T{}, <>) // objType=T variadic=true
- // append([]T{}, T{}, <>) // objType=T variadic=false
- variadic bool
-
- // modifiers are prefixes such as "*", "&" or "<-" that influence how
- // a candidate type relates to the expected type.
- modifiers []typeModifier
-
- // convertibleTo is a type our candidate type must be convertible to.
- convertibleTo types.Type
-
- // typeName holds information about the expected type name at
- // position, if any.
- typeName typeNameInference
-
- // assignees are the types that would receive a function call's
- // results at the position. For example:
- //
- // foo := 123
- // foo, bar := <>
- //
- // at "<>", the assignees are [int, <invalid>].
- assignees []types.Type
-
- // variadicAssignees is true if we could be completing an inner
- // function call that fills out an outer function call's variadic
- // params. For example:
- //
- // func foo(int, ...string) {}
- //
- // foo(<>) // variadicAssignees=true
- // foo(bar<>) // variadicAssignees=true
- // foo(bar, baz<>) // variadicAssignees=false
- variadicAssignees bool
-
- // penalized holds expressions that should be disfavored as
- // candidates. For example, it tracks expressions already used in a
- // switch statement's other cases. Each expression is tracked using
- // its entire object "chain" allowing differentiation between
- // "a.foo" and "b.foo" when "a" and "b" are the same type.
- penalized []penalizedObj
-
- // objChain contains the chain of objects representing the
- // surrounding *ast.SelectorExpr. For example, if we are completing
- // "foo.bar.ba<>", objChain will contain []types.Object{foo, bar}.
- objChain []types.Object
-}
-
-// typeNameInference holds information about the expected type name at
-// position.
-type typeNameInference struct {
- // wantTypeName is true if we expect the name of a type.
- wantTypeName bool
-
- // modifiers are prefixes such as "*", "&" or "<-" that influence how
- // a candidate type relates to the expected type.
- modifiers []typeModifier
-
- // assertableFrom is a type that must be assertable to our candidate type.
- assertableFrom types.Type
-
- // wantComparable is true if we want a comparable type.
- wantComparable bool
-
- // seenTypeSwitchCases tracks types that have already been used by
- // the containing type switch.
- seenTypeSwitchCases []types.Type
-
- // compLitType is true if we are completing a composite literal type
- // name, e.g "foo<>{}".
- compLitType bool
-}
-
-// expectedCandidate returns information about the expected candidate
-// for an expression at the query position.
-func expectedCandidate(ctx context.Context, c *completer) (inf candidateInference) {
- inf.typeName = expectTypeName(c)
-
- if c.enclosingCompositeLiteral != nil {
- inf.objType = c.expectedCompositeLiteralType()
- }
-
-Nodes:
- for i, node := range c.path {
- switch node := node.(type) {
- case *ast.BinaryExpr:
- // Determine if query position comes from left or right of op.
- e := node.X
- if c.pos < node.OpPos {
- e = node.Y
- }
- if tv, ok := c.pkg.GetTypesInfo().Types[e]; ok {
- switch node.Op {
- case token.LAND, token.LOR:
- // Don't infer "bool" type for "&&" or "||". Often you want
- // to compose a boolean expression from non-boolean
- // candidates.
- default:
- inf.objType = tv.Type
- }
- break Nodes
- }
- case *ast.AssignStmt:
- // Only rank completions if you are on the right side of the token.
- if c.pos > node.TokPos {
- i := exprAtPos(c.pos, node.Rhs)
- if i >= len(node.Lhs) {
- i = len(node.Lhs) - 1
- }
- if tv, ok := c.pkg.GetTypesInfo().Types[node.Lhs[i]]; ok {
- inf.objType = tv.Type
- }
-
- // If we have a single expression on the RHS, record the LHS
- // assignees so we can favor multi-return function calls with
- // matching result values.
- if len(node.Rhs) <= 1 {
- for _, lhs := range node.Lhs {
- inf.assignees = append(inf.assignees, c.pkg.GetTypesInfo().TypeOf(lhs))
- }
- } else {
- // Otherwse, record our single assignee, even if its type is
- // not available. We use this info to downrank functions
- // with the wrong number of result values.
- inf.assignees = append(inf.assignees, c.pkg.GetTypesInfo().TypeOf(node.Lhs[i]))
- }
- }
- return inf
- case *ast.ValueSpec:
- if node.Type != nil && c.pos > node.Type.End() {
- inf.objType = c.pkg.GetTypesInfo().TypeOf(node.Type)
- }
- return inf
- case *ast.CallExpr:
- // Only consider CallExpr args if position falls between parens.
- if node.Lparen < c.pos && c.pos <= node.Rparen {
- // For type conversions like "int64(foo)" we can only infer our
- // desired type is convertible to int64.
- if typ := typeConversion(node, c.pkg.GetTypesInfo()); typ != nil {
- inf.convertibleTo = typ
- break Nodes
- }
-
- if tv, ok := c.pkg.GetTypesInfo().Types[node.Fun]; ok {
- if sig, ok := tv.Type.(*types.Signature); ok {
- numParams := sig.Params().Len()
- if numParams == 0 {
- return inf
- }
-
- exprIdx := exprAtPos(c.pos, node.Args)
-
- // If we have one or zero arg expressions, we may be
- // completing to a function call that returns multiple
- // values, in turn getting passed in to the surrounding
- // call. Record the assignees so we can favor function
- // calls that return matching values.
- if len(node.Args) <= 1 && exprIdx == 0 {
- for i := 0; i < sig.Params().Len(); i++ {
- inf.assignees = append(inf.assignees, sig.Params().At(i).Type())
- }
-
- // Record that we may be completing into variadic parameters.
- inf.variadicAssignees = sig.Variadic()
- }
-
- // Make sure not to run past the end of expected parameters.
- if exprIdx >= numParams {
- inf.objType = sig.Params().At(numParams - 1).Type()
- } else {
- inf.objType = sig.Params().At(exprIdx).Type()
- }
-
- if sig.Variadic() && exprIdx >= (numParams-1) {
- // If we are completing a variadic param, deslice the variadic type.
- inf.objType = deslice(inf.objType)
- // Record whether we are completing the initial variadic param.
- inf.variadic = exprIdx == numParams-1 && len(node.Args) <= numParams
-
- // Check if we can infer object kind from printf verb.
- inf.objKind |= printfArgKind(c.pkg.GetTypesInfo(), node, exprIdx)
- }
- }
- }
-
- if funIdent, ok := node.Fun.(*ast.Ident); ok {
- obj := c.pkg.GetTypesInfo().ObjectOf(funIdent)
-
- if obj != nil && obj.Parent() == types.Universe {
- // Defer call to builtinArgType so we can provide it the
- // inferred type from its parent node.
- defer func() {
- inf = c.builtinArgType(obj, node, inf)
- inf.objKind = c.builtinArgKind(ctx, obj, node)
- }()
-
- // The expected type of builtin arguments like append() is
- // the expected type of the builtin call itself. For
- // example:
- //
- // var foo []int = append(<>)
- //
- // To find the expected type at <> we "skip" the append()
- // node and get the expected type one level up, which is
- // []int.
- continue Nodes
- }
- }
-
- return inf
- }
- case *ast.ReturnStmt:
- if c.enclosingFunc != nil {
- sig := c.enclosingFunc.sig
- // Find signature result that corresponds to our return statement.
- if resultIdx := exprAtPos(c.pos, node.Results); resultIdx < len(node.Results) {
- if resultIdx < sig.Results().Len() {
- inf.objType = sig.Results().At(resultIdx).Type()
- }
- }
- }
- return inf
- case *ast.CaseClause:
- if swtch, ok := findSwitchStmt(c.path[i+1:], c.pos, node).(*ast.SwitchStmt); ok {
- if tv, ok := c.pkg.GetTypesInfo().Types[swtch.Tag]; ok {
- inf.objType = tv.Type
-
- // Record which objects have already been used in the case
- // statements so we don't suggest them again.
- for _, cc := range swtch.Body.List {
- for _, caseExpr := range cc.(*ast.CaseClause).List {
- // Don't record the expression we are currently completing.
- if caseExpr.Pos() < c.pos && c.pos <= caseExpr.End() {
- continue
- }
-
- if objs := objChain(c.pkg.GetTypesInfo(), caseExpr); len(objs) > 0 {
- inf.penalized = append(inf.penalized, penalizedObj{objChain: objs, penalty: 0.1})
- }
- }
- }
- }
- }
- return inf
- case *ast.SliceExpr:
- // Make sure position falls within the brackets (e.g. "foo[a:<>]").
- if node.Lbrack < c.pos && c.pos <= node.Rbrack {
- inf.objType = types.Typ[types.Int]
- }
- return inf
- case *ast.IndexExpr:
- // Make sure position falls within the brackets (e.g. "foo[<>]").
- if node.Lbrack < c.pos && c.pos <= node.Rbrack {
- if tv, ok := c.pkg.GetTypesInfo().Types[node.X]; ok {
- switch t := tv.Type.Underlying().(type) {
- case *types.Map:
- inf.objType = t.Key()
- case *types.Slice, *types.Array:
- inf.objType = types.Typ[types.Int]
- }
- }
- }
- return inf
- case *ast.SendStmt:
- // Make sure we are on right side of arrow (e.g. "foo <- <>").
- if c.pos > node.Arrow+1 {
- if tv, ok := c.pkg.GetTypesInfo().Types[node.Chan]; ok {
- if ch, ok := tv.Type.Underlying().(*types.Chan); ok {
- inf.objType = ch.Elem()
- }
- }
- }
- return inf
- case *ast.RangeStmt:
- if source.NodeContains(node.X, c.pos) {
- inf.objKind |= kindSlice | kindArray | kindMap | kindString
- if node.Value == nil {
- inf.objKind |= kindChan
- }
- }
- return inf
- case *ast.StarExpr:
- inf.modifiers = append(inf.modifiers, typeModifier{mod: dereference})
- case *ast.UnaryExpr:
- switch node.Op {
- case token.AND:
- inf.modifiers = append(inf.modifiers, typeModifier{mod: reference})
- case token.ARROW:
- inf.modifiers = append(inf.modifiers, typeModifier{mod: chanRead})
- }
- case *ast.DeferStmt, *ast.GoStmt:
- inf.objKind |= kindFunc
- return inf
- default:
- if breaksExpectedTypeInference(node, c.pos) {
- return inf
- }
- }
- }
-
- return inf
-}
-
-// objChain decomposes e into a chain of objects if possible. For
-// example, "foo.bar().baz" will yield []types.Object{foo, bar, baz}.
-// If any part can't be turned into an object, return nil.
-func objChain(info *types.Info, e ast.Expr) []types.Object {
- var objs []types.Object
-
- for e != nil {
- switch n := e.(type) {
- case *ast.Ident:
- obj := info.ObjectOf(n)
- if obj == nil {
- return nil
- }
- objs = append(objs, obj)
- e = nil
- case *ast.SelectorExpr:
- obj := info.ObjectOf(n.Sel)
- if obj == nil {
- return nil
- }
- objs = append(objs, obj)
- e = n.X
- case *ast.CallExpr:
- if len(n.Args) > 0 {
- return nil
- }
- e = n.Fun
- default:
- return nil
- }
- }
-
- // Reverse order so the layout matches the syntactic order.
- for i := 0; i < len(objs)/2; i++ {
- objs[i], objs[len(objs)-1-i] = objs[len(objs)-1-i], objs[i]
- }
-
- return objs
-}
-
-// applyTypeModifiers applies the list of type modifiers to a type.
-// It returns nil if the modifiers could not be applied.
-func (ci candidateInference) applyTypeModifiers(typ types.Type, addressable bool) types.Type {
- for _, mod := range ci.modifiers {
- switch mod.mod {
- case dereference:
- // For every "*" indirection operator, remove a pointer layer
- // from candidate type.
- if ptr, ok := typ.Underlying().(*types.Pointer); ok {
- typ = ptr.Elem()
- } else {
- return nil
- }
- case reference:
- // For every "&" address operator, add another pointer layer to
- // candidate type, if the candidate is addressable.
- if addressable {
- typ = types.NewPointer(typ)
- } else {
- return nil
- }
- case chanRead:
- // For every "<-" operator, remove a layer of channelness.
- if ch, ok := typ.(*types.Chan); ok {
- typ = ch.Elem()
- } else {
- return nil
- }
- }
- }
-
- return typ
-}
-
-// applyTypeNameModifiers applies the list of type modifiers to a type name.
-func (ci candidateInference) applyTypeNameModifiers(typ types.Type) types.Type {
- for _, mod := range ci.typeName.modifiers {
- switch mod.mod {
- case reference:
- typ = types.NewPointer(typ)
- case array:
- typ = types.NewArray(typ, mod.arrayLen)
- case slice:
- typ = types.NewSlice(typ)
- }
- }
- return typ
-}
-
-// matchesVariadic returns true if we are completing a variadic
-// parameter and candType is a compatible slice type.
-func (ci candidateInference) matchesVariadic(candType types.Type) bool {
- return ci.variadic && ci.objType != nil && types.AssignableTo(candType, types.NewSlice(ci.objType))
-}
-
-// findSwitchStmt returns an *ast.CaseClause's corresponding *ast.SwitchStmt or
-// *ast.TypeSwitchStmt. path should start from the case clause's first ancestor.
-func findSwitchStmt(path []ast.Node, pos token.Pos, c *ast.CaseClause) ast.Stmt {
- // Make sure position falls within a "case <>:" clause.
- if exprAtPos(pos, c.List) >= len(c.List) {
- return nil
- }
- // A case clause is always nested within a block statement in a switch statement.
- if len(path) < 2 {
- return nil
- }
- if _, ok := path[0].(*ast.BlockStmt); !ok {
- return nil
- }
- switch s := path[1].(type) {
- case *ast.SwitchStmt:
- return s
- case *ast.TypeSwitchStmt:
- return s
- default:
- return nil
- }
-}
-
-// breaksExpectedTypeInference reports if an expression node's type is unrelated
-// to its child expression node types. For example, "Foo{Bar: x.Baz(<>)}" should
-// expect a function argument, not a composite literal value.
-func breaksExpectedTypeInference(n ast.Node, pos token.Pos) bool {
- switch n := n.(type) {
- case *ast.CompositeLit:
- // Doesn't break inference if pos is in type name.
- // For example: "Foo<>{Bar: 123}"
- return !source.NodeContains(n.Type, pos)
- case *ast.CallExpr:
- // Doesn't break inference if pos is in func name.
- // For example: "Foo<>(123)"
- return !source.NodeContains(n.Fun, pos)
- case *ast.FuncLit, *ast.IndexExpr, *ast.SliceExpr:
- return true
- default:
- return false
- }
-}
-
-// expectTypeName returns information about the expected type name at position.
-func expectTypeName(c *completer) typeNameInference {
- var inf typeNameInference
-
-Nodes:
- for i, p := range c.path {
- switch n := p.(type) {
- case *ast.FieldList:
- // Expect a type name if pos is in a FieldList. This applies to
- // FuncType params/results, FuncDecl receiver, StructType, and
- // InterfaceType. We don't need to worry about the field name
- // because completion bails out early if pos is in an *ast.Ident
- // that defines an object.
- inf.wantTypeName = true
- break Nodes
- case *ast.CaseClause:
- // Expect type names in type switch case clauses.
- if swtch, ok := findSwitchStmt(c.path[i+1:], c.pos, n).(*ast.TypeSwitchStmt); ok {
- // The case clause types must be assertable from the type switch parameter.
- ast.Inspect(swtch.Assign, func(n ast.Node) bool {
- if ta, ok := n.(*ast.TypeAssertExpr); ok {
- inf.assertableFrom = c.pkg.GetTypesInfo().TypeOf(ta.X)
- return false
- }
- return true
- })
- inf.wantTypeName = true
-
- // Track the types that have already been used in this
- // switch's case statements so we don't recommend them.
- for _, e := range swtch.Body.List {
- for _, typeExpr := range e.(*ast.CaseClause).List {
- // Skip if type expression contains pos. We don't want to
- // count it as already used if the user is completing it.
- if typeExpr.Pos() < c.pos && c.pos <= typeExpr.End() {
- continue
- }
-
- if t := c.pkg.GetTypesInfo().TypeOf(typeExpr); t != nil {
- inf.seenTypeSwitchCases = append(inf.seenTypeSwitchCases, t)
- }
- }
- }
-
- break Nodes
- }
- return typeNameInference{}
- case *ast.TypeAssertExpr:
- // Expect type names in type assert expressions.
- if n.Lparen < c.pos && c.pos <= n.Rparen {
- // The type in parens must be assertable from the expression type.
- inf.assertableFrom = c.pkg.GetTypesInfo().TypeOf(n.X)
- inf.wantTypeName = true
- break Nodes
- }
- return typeNameInference{}
- case *ast.StarExpr:
- inf.modifiers = append(inf.modifiers, typeModifier{mod: reference})
- case *ast.CompositeLit:
- // We want a type name if position is in the "Type" part of a
- // composite literal (e.g. "Foo<>{}").
- if n.Type != nil && n.Type.Pos() <= c.pos && c.pos <= n.Type.End() {
- inf.wantTypeName = true
- inf.compLitType = true
-
- if i < len(c.path)-1 {
- // Track preceding "&" operator. Technically it applies to
- // the composite literal and not the type name, but if
- // affects our type completion nonetheless.
- if u, ok := c.path[i+1].(*ast.UnaryExpr); ok && u.Op == token.AND {
- inf.modifiers = append(inf.modifiers, typeModifier{mod: reference})
- }
- }
- }
- break Nodes
- case *ast.ArrayType:
- // If we are inside the "Elt" part of an array type, we want a type name.
- if n.Elt.Pos() <= c.pos && c.pos <= n.Elt.End() {
- inf.wantTypeName = true
- if n.Len == nil {
- // No "Len" expression means a slice type.
- inf.modifiers = append(inf.modifiers, typeModifier{mod: slice})
- } else {
- // Try to get the array type using the constant value of "Len".
- tv, ok := c.pkg.GetTypesInfo().Types[n.Len]
- if ok && tv.Value != nil && tv.Value.Kind() == constant.Int {
- if arrayLen, ok := constant.Int64Val(tv.Value); ok {
- inf.modifiers = append(inf.modifiers, typeModifier{mod: array, arrayLen: arrayLen})
- }
- }
- }
-
- // ArrayTypes can be nested, so keep going if our parent is an
- // ArrayType.
- if i < len(c.path)-1 {
- if _, ok := c.path[i+1].(*ast.ArrayType); ok {
- continue Nodes
- }
- }
-
- break Nodes
- }
- case *ast.MapType:
- inf.wantTypeName = true
- if n.Key != nil {
- inf.wantComparable = source.NodeContains(n.Key, c.pos)
- } else {
- // If the key is empty, assume we are completing the key if
- // pos is directly after the "map[".
- inf.wantComparable = c.pos == n.Pos()+token.Pos(len("map["))
- }
- break Nodes
- case *ast.ValueSpec:
- inf.wantTypeName = source.NodeContains(n.Type, c.pos)
- break Nodes
- case *ast.TypeSpec:
- inf.wantTypeName = source.NodeContains(n.Type, c.pos)
- default:
- if breaksExpectedTypeInference(p, c.pos) {
- return typeNameInference{}
- }
- }
- }
-
- return inf
-}
-
-func (c *completer) fakeObj(T types.Type) *types.Var {
- return types.NewVar(token.NoPos, c.pkg.GetTypes(), "", T)
-}
-
-// anyCandType reports whether f returns true for any candidate type
-// derivable from c. For example, from "foo" we might derive "&foo",
-// and "foo()".
-func (c *candidate) anyCandType(f func(t types.Type, addressable bool) bool) bool {
- if c.obj == nil || c.obj.Type() == nil {
- return false
- }
-
- objType := c.obj.Type()
-
- if f(objType, c.addressable) {
- return true
- }
-
- // If c is a func type with a single result, offer the result type.
- if sig, ok := objType.Underlying().(*types.Signature); ok {
- if sig.Results().Len() == 1 && f(sig.Results().At(0).Type(), false) {
- // Mark the candidate so we know to append "()" when formatting.
- c.expandFuncCall = true
- return true
- }
- }
-
- var (
- seenPtrTypes map[types.Type]bool
- ptrType = objType
- ptrDepth int
- )
-
- // Check if dereferencing c would match our type inference. We loop
- // since c could have arbitrary levels of pointerness.
- for {
- ptr, ok := ptrType.Underlying().(*types.Pointer)
- if !ok {
- break
- }
-
- ptrDepth++
-
- // Avoid pointer type cycles.
- if seenPtrTypes[ptrType] {
- break
- }
-
- if _, named := ptrType.(*types.Named); named {
- // Lazily allocate "seen" since it isn't used normally.
- if seenPtrTypes == nil {
- seenPtrTypes = make(map[types.Type]bool)
- }
-
- // Track named pointer types we have seen to detect cycles.
- seenPtrTypes[ptrType] = true
- }
-
- if f(ptr.Elem(), false) {
- // Mark the candidate so we know to prepend "*" when formatting.
- c.dereference = ptrDepth
- return true
- }
-
- ptrType = ptr.Elem()
- }
-
- // Check if c is addressable and a pointer to c matches our type inference.
- if c.addressable && f(types.NewPointer(objType), false) {
- // Mark the candidate so we know to prepend "&" when formatting.
- c.takeAddress = true
- return true
- }
-
- return false
-}
-
-// matchingCandidate reports whether cand matches our type inferences.
-// It mutates cand's score in certain cases.
-func (c *completer) matchingCandidate(cand *candidate) bool {
- if c.completionContext.commentCompletion {
- return false
- }
-
- if isTypeName(cand.obj) {
- return c.matchingTypeName(cand)
- } else if c.wantTypeName() {
- // If we want a type, a non-type object never matches.
- return false
- }
-
- if c.inference.candTypeMatches(cand) {
- return true
- }
-
- candType := cand.obj.Type()
- if candType == nil {
- return false
- }
-
- if sig, ok := candType.Underlying().(*types.Signature); ok {
- if c.inference.assigneesMatch(cand, sig) {
- // Invoke the candidate if its results are multi-assignable.
- cand.expandFuncCall = true
- return true
- }
- }
-
- // Default to invoking *types.Func candidates. This is so function
- // completions in an empty statement (or other cases with no expected type)
- // are invoked by default.
- cand.expandFuncCall = isFunc(cand.obj)
-
- return false
-}
-
-// candTypeMatches reports whether cand makes a good completion
-// candidate given the candidate inference. cand's score may be
-// mutated to downrank the candidate in certain situations.
-func (ci *candidateInference) candTypeMatches(cand *candidate) bool {
- var (
- expTypes = make([]types.Type, 0, 2)
- variadicType types.Type
- )
- if ci.objType != nil {
- expTypes = append(expTypes, ci.objType)
-
- if ci.variadic {
- variadicType = types.NewSlice(ci.objType)
- expTypes = append(expTypes, variadicType)
- }
- }
-
- return cand.anyCandType(func(candType types.Type, addressable bool) bool {
- // Take into account any type modifiers on the expected type.
- candType = ci.applyTypeModifiers(candType, addressable)
- if candType == nil {
- return false
- }
-
- if ci.convertibleTo != nil && types.ConvertibleTo(candType, ci.convertibleTo) {
- return true
- }
-
- for _, expType := range expTypes {
- if isEmptyInterface(expType) {
- continue
- }
-
- matches, untyped := ci.typeMatches(expType, candType)
- if !matches {
- continue
- }
-
- if expType == variadicType {
- cand.variadic = true
- }
-
- // Lower candidate score for untyped conversions. This avoids
- // ranking untyped constants above candidates with an exact type
- // match. Don't lower score of builtin constants, e.g. "true".
- if untyped && !types.Identical(candType, expType) && cand.obj.Parent() != types.Universe {
- cand.score /= 2
- }
-
- return true
- }
-
- // If we don't have a specific expected type, fall back to coarser
- // object kind checks.
- if ci.objType == nil || isEmptyInterface(ci.objType) {
- // If we were able to apply type modifiers to our candidate type,
- // count that as a match. For example:
- //
- // var foo chan int
- // <-fo<>
- //
- // We were able to apply the "<-" type modifier to "foo", so "foo"
- // matches.
- if len(ci.modifiers) > 0 {
- return true
- }
-
- // If we didn't have an exact type match, check if our object kind
- // matches.
- if ci.kindMatches(candType) {
- if ci.objKind == kindFunc {
- cand.expandFuncCall = true
- }
- return true
- }
- }
-
- return false
- })
-}
-
-// typeMatches reports whether an object of candType makes a good
-// completion candidate given the expected type expType. It also
-// returns a second bool which is true if both types are basic types
-// of the same kind, and at least one is untyped.
-func (ci *candidateInference) typeMatches(expType, candType types.Type) (bool, bool) {
- // Handle untyped values specially since AssignableTo gives false negatives
- // for them (see https://golang.org/issue/32146).
- if candBasic, ok := candType.Underlying().(*types.Basic); ok {
- if wantBasic, ok := expType.Underlying().(*types.Basic); ok {
- // Make sure at least one of them is untyped.
- if isUntyped(candType) || isUntyped(expType) {
- // Check that their constant kind (bool|int|float|complex|string) matches.
- // This doesn't take into account the constant value, so there will be some
- // false positives due to integer sign and overflow.
- if candBasic.Info()&types.IsConstType == wantBasic.Info()&types.IsConstType {
- return true, true
- }
- }
- }
- }
-
- // AssignableTo covers the case where the types are equal, but also handles
- // cases like assigning a concrete type to an interface type.
- return types.AssignableTo(candType, expType), false
-}
-
-// kindMatches reports whether candType's kind matches our expected
-// kind (e.g. slice, map, etc.).
-func (ci *candidateInference) kindMatches(candType types.Type) bool {
- return ci.objKind > 0 && ci.objKind&candKind(candType) > 0
-}
-
-// assigneesMatch reports whether an invocation of sig matches the
-// number and type of any assignees.
-func (ci *candidateInference) assigneesMatch(cand *candidate, sig *types.Signature) bool {
- if len(ci.assignees) == 0 {
- return false
- }
-
- // Uniresult functions are always usable and are handled by the
- // normal, non-assignees type matching logic.
- if sig.Results().Len() == 1 {
- return false
- }
-
- var numberOfResultsCouldMatch bool
- if ci.variadicAssignees {
- numberOfResultsCouldMatch = sig.Results().Len() >= len(ci.assignees)-1
- } else {
- numberOfResultsCouldMatch = sig.Results().Len() == len(ci.assignees)
- }
-
- // If our signature doesn't return the right number of values, it's
- // not a match, so downrank it. For example:
- //
- // var foo func() (int, int)
- // a, b, c := <> // downrank "foo()" since it only returns two values
- if !numberOfResultsCouldMatch {
- cand.score /= 2
- return false
- }
-
- // If at least one assignee has a valid type, and all valid
- // assignees match the corresponding sig result value, the signature
- // is a match.
- allMatch := false
- for i := 0; i < sig.Results().Len(); i++ {
- var assignee types.Type
-
- // If we are completing into variadic parameters, deslice the
- // expected variadic type.
- if ci.variadicAssignees && i >= len(ci.assignees)-1 {
- assignee = ci.assignees[len(ci.assignees)-1]
- if elem := deslice(assignee); elem != nil {
- assignee = elem
- }
- } else {
- assignee = ci.assignees[i]
- }
-
- if assignee == nil {
- continue
- }
-
- allMatch, _ = ci.typeMatches(assignee, sig.Results().At(i).Type())
- if !allMatch {
- break
- }
- }
- return allMatch
-}
-
-func (c *completer) matchingTypeName(cand *candidate) bool {
- if !c.wantTypeName() {
- return false
- }
-
- typeMatches := func(candType types.Type) bool {
- // Take into account any type name modifier prefixes.
- candType = c.inference.applyTypeNameModifiers(candType)
-
- if from := c.inference.typeName.assertableFrom; from != nil {
- // Don't suggest the starting type in type assertions. For example,
- // if "foo" is an io.Writer, don't suggest "foo.(io.Writer)".
- if types.Identical(from, candType) {
- return false
- }
-
- if intf, ok := from.Underlying().(*types.Interface); ok {
- if !types.AssertableTo(intf, candType) {
- return false
- }
- }
- }
-
- if c.inference.typeName.wantComparable && !types.Comparable(candType) {
- return false
- }
-
- // Skip this type if it has already been used in another type
- // switch case.
- for _, seen := range c.inference.typeName.seenTypeSwitchCases {
- if types.Identical(candType, seen) {
- return false
- }
- }
-
- // We can expect a type name and have an expected type in cases like:
- //
- // var foo []int
- // foo = []i<>
- //
- // Where our expected type is "[]int", and we expect a type name.
- if c.inference.objType != nil {
- return types.AssignableTo(candType, c.inference.objType)
- }
-
- // Default to saying any type name is a match.
- return true
- }
-
- t := cand.obj.Type()
-
- if typeMatches(t) {
- return true
- }
-
- if !source.IsInterface(t) && typeMatches(types.NewPointer(t)) {
- if c.inference.typeName.compLitType {
- // If we are completing a composite literal type as in
- // "foo<>{}", to make a pointer we must prepend "&".
- cand.takeAddress = true
- } else {
- // If we are completing a normal type name such as "foo<>", to
- // make a pointer we must prepend "*".
- cand.makePointer = true
- }
- return true
- }
-
- return false
-}
-
-var (
- // "interface { Error() string }" (i.e. error)
- errorIntf = types.Universe.Lookup("error").Type().Underlying().(*types.Interface)
-
- // "interface { String() string }" (i.e. fmt.Stringer)
- stringerIntf = types.NewInterfaceType([]*types.Func{
- types.NewFunc(token.NoPos, nil, "String", types.NewSignature(
- nil,
- nil,
- types.NewTuple(types.NewParam(token.NoPos, nil, "", types.Typ[types.String])),
- false,
- )),
- }, nil).Complete()
-
- byteType = types.Universe.Lookup("byte").Type()
-)
-
-// candKind returns the objKind of candType, if any.
-func candKind(candType types.Type) objKind {
- var kind objKind
-
- switch t := candType.Underlying().(type) {
- case *types.Array:
- kind |= kindArray
- if t.Elem() == byteType {
- kind |= kindBytes
- }
- case *types.Slice:
- kind |= kindSlice
- if t.Elem() == byteType {
- kind |= kindBytes
- }
- case *types.Chan:
- kind |= kindChan
- case *types.Map:
- kind |= kindMap
- case *types.Pointer:
- kind |= kindPtr
-
- // Some builtins handle array pointers as arrays, so just report a pointer
- // to an array as an array.
- if _, isArray := t.Elem().Underlying().(*types.Array); isArray {
- kind |= kindArray
- }
- case *types.Basic:
- switch info := t.Info(); {
- case info&types.IsString > 0:
- kind |= kindString
- case info&types.IsInteger > 0:
- kind |= kindInt
- case info&types.IsFloat > 0:
- kind |= kindFloat
- case info&types.IsComplex > 0:
- kind |= kindComplex
- case info&types.IsBoolean > 0:
- kind |= kindBool
- }
- case *types.Signature:
- return kindFunc
- }
-
- if types.Implements(candType, errorIntf) {
- kind |= kindError
- }
-
- if types.Implements(candType, stringerIntf) {
- kind |= kindStringer
- }
-
- return kind
-}
projects / dotfiles / .git / blobdiff