lsp/symbols: documentSymbol

gopls/internal/goxls/imports/imports.go

@@ -171,145 +171,8 @@ func parse(fset *token.FileSet, filename string, src []byte, opt *Options) (*ast
  parserMode |= parser.AllErrors
  }
 
- // Try as whole source file.
  file, err := parser.ParseFile(fset, filename, src, parserMode)
- if err == nil {
- return file, nil, nil
- }
- // If the error is that the source file didn't begin with a
- // package line and we accept fragmented input, fall through to
- // try as a source fragment. Stop and return on any other error.
- if !opt.Fragment || !strings.Contains(err.Error(), "expected 'package'") {
- return nil, nil, err
- }
-
- // If this is a declaration list, make it a source file
- // by inserting a package clause.
- // Insert using a ;, not a newline, so that parse errors are on
- // the correct line.
- const prefix = "package main;"
- psrc := append([]byte(prefix), src...)
- file, err = parser.ParseFile(fset, filename, psrc, parserMode)
- if err == nil {
- // Gofmt will turn the ; into a \n.
- // Do that ourselves now and update the file contents,
- // so that positions and line numbers are correct going forward.
- psrc[len(prefix)-1] = '\n'
- fset.File(file.Package).SetLinesForContent(psrc)
-
- // If a main function exists, we will assume this is a main
- // package and leave the file.
- if containsMainFunc(file) {
- return file, nil, nil
- }
-
- adjust := func(orig, src []byte) []byte {
- // Remove the package clause.
- src = src[len(prefix):]
- return matchSpace(orig, src)
- }
- return file, adjust, nil
- }
- // If the error is that the source file didn't begin with a
- // declaration, fall through to try as a statement list.
- // Stop and return on any other error.
- if !strings.Contains(err.Error(), "expected declaration") {
- return nil, nil, err
- }
-
- // If this is a statement list, make it a source file
- // by inserting a package clause and turning the list
- // into a function body. This handles expressions too.
- // Insert using a ;, not a newline, so that the line numbers
- // in fsrc match the ones in src.
- fsrc := append(append([]byte("package p; func _() {"), src...), '}')
- file, err = parser.ParseFile(fset, filename, fsrc, parserMode)
- if err == nil {
- adjust := func(orig, src []byte) []byte {
- // Remove the wrapping.
- // Gofmt has turned the ; into a \n\n.
- src = src[len("package p\n\nfunc _() {"):]
- src = src[:len(src)-len("}\n")]
- // Gofmt has also indented the function body one level.
- // Remove that indent.
- src = bytes.Replace(src, []byte("\n\t"), []byte("\n"), -1)
- return matchSpace(orig, src)
- }
- return file, adjust, nil
- }
-
- // Failed, and out of options.
- return nil, nil, err
-}
-
-// containsMainFunc checks if a file contains a function declaration with the
-// function signature 'func main()'
-func containsMainFunc(file *ast.File) bool {
- for _, decl := range file.Decls {
- if f, ok := decl.(*ast.FuncDecl); ok {
- if f.Name.Name != "main" {
- continue
- }
-
- if len(f.Type.Params.List) != 0 {
- continue
- }
-
- if f.Type.Results != nil && len(f.Type.Results.List) != 0 {
- continue
- }
-
- return true
- }
- }
-
- return false
-}
-
-func cutSpace(b []byte) (before, middle, after []byte) {
- i := 0
- for i < len(b) && (b[i] == ' ' || b[i] == '\t' || b[i] == '\n') {
- i++
- }
- j := len(b)
- for j > 0 && (b[j-1] == ' ' || b[j-1] == '\t' || b[j-1] == '\n') {
- j--
- }
- if i <= j {
- return b[:i], b[i:j], b[j:]
- }
- return nil, nil, b[j:]
-}
-
-// matchSpace reformats src to use the same space context as orig.
-// 1. If orig begins with blank lines, matchSpace inserts them at the beginning of src.
-// 2. matchSpace copies the indentation of the first non-blank line in orig
-// to every non-blank line in src.
-// 3. matchSpace copies the trailing space from orig and uses it in place
-// of src's trailing space.
-func matchSpace(orig []byte, src []byte) []byte {
- before, _, after := cutSpace(orig)
- i := bytes.LastIndex(before, []byte{'\n'})
- before, indent := before[:i+1], before[i+1:]
-
- _, src, _ = cutSpace(src)
-
- var b bytes.Buffer
- b.Write(before)
- for len(src) > 0 {
- line := src
- if i := bytes.IndexByte(line, '\n'); i >= 0 {
- line, src = line[:i+1], line[i+1:]
- } else {
- src = nil
- }
- if len(line) > 0 && line[0] != '\n' { // not blank
- b.Write(indent)
- }
- b.Write(line)
- }
- b.Write(after)
- return b.Bytes()
+ return file, nil, err
 }
 
 var impLine = regexp.MustCompile(`^\s+(?:[\w\.]+\s+)?"(.+?)"`)

gopls/internal/goxls/imports/mod.go

@@ -296,10 +296,6 @@ func (r *ModuleResolver) cacheStore(info directoryPackageInfo) {
  }
 }
 
-func (r *ModuleResolver) cacheKeys() []string {
- return append(r.moduleCacheCache.Keys(), r.otherCache.Keys()...)
-}
-
 // cachePackageName caches the package name for a dir already in the cache.
 func (r *ModuleResolver) cachePackageName(info directoryPackageInfo) (string, error) {
  if info.rootType == gopathwalk.RootModuleCache {

gopls/internal/goxls/typesutil/exprstring.go

@@ -0,0 +1,237 @@
+// Copyright 2023 The GoPlus Authors (goplus.org). All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typesutil
+
+import (
+ "bytes"
+ "fmt"
+
+ "github.com/goplus/gop/ast"
+ "golang.org/x/tools/gopls/internal/goxls/typesutil/typeparams"
+)
+
+// ExprString returns the (possibly shortened) string representation for x.
+// Shortened representations are suitable for user interfaces but may not
+// necessarily follow Go syntax.
+func ExprString(x ast.Expr) string {
+ var buf bytes.Buffer
+ WriteExpr(&buf, x)
+ return buf.String()
+}
+
+// WriteExpr writes the (possibly shortened) string representation for x to buf.
+// Shortened representations are suitable for user interfaces but may not
+// necessarily follow Go syntax.
+func WriteExpr(buf *bytes.Buffer, x ast.Expr) {
+ // The AST preserves source-level parentheses so there is
+ // no need to introduce them here to correct for different
+ // operator precedences. (This assumes that the AST was
+ // generated by a Go parser.)
+
+ switch x := x.(type) {
+ default:
+ fmt.Fprintf(buf, "(ast: %T)", x) // nil, ast.BadExpr, ast.KeyValueExpr
+
+ case *ast.Ident:
+ buf.WriteString(x.Name)
+
+ case *ast.Ellipsis:
+ buf.WriteString("...")
+ if x.Elt != nil {
+ WriteExpr(buf, x.Elt)
+ }
+
+ case *ast.BasicLit:
+ buf.WriteString(x.Value)
+
+ case *ast.FuncLit:
+ buf.WriteByte('(')
+ WriteExpr(buf, x.Type)
+ buf.WriteString(" literal)") // shortened
+
+ case *ast.CompositeLit:
+ WriteExpr(buf, x.Type)
+ buf.WriteByte('{')
+ if len(x.Elts) > 0 {
+ buf.WriteString("…")
+ }
+ buf.WriteByte('}')
+
+ case *ast.ParenExpr:
+ buf.WriteByte('(')
+ WriteExpr(buf, x.X)
+ buf.WriteByte(')')
+
+ case *ast.SelectorExpr:
+ WriteExpr(buf, x.X)
+ buf.WriteByte('.')
+ buf.WriteString(x.Sel.Name)
+
+ case *ast.IndexExpr, *ast.IndexListExpr:
+ ix := typeparams.UnpackIndexExpr(x)
+ WriteExpr(buf, ix.X)
+ buf.WriteByte('[')
+ writeExprList(buf, ix.Indices)
+ buf.WriteByte(']')
+
+ case *ast.SliceExpr:
+ WriteExpr(buf, x.X)
+ buf.WriteByte('[')
+ if x.Low != nil {
+ WriteExpr(buf, x.Low)
+ }
+ buf.WriteByte(':')
+ if x.High != nil {
+ WriteExpr(buf, x.High)
+ }
+ if x.Slice3 {
+ buf.WriteByte(':')
+ if x.Max != nil {
+ WriteExpr(buf, x.Max)
+ }
+ }
+ buf.WriteByte(']')
+
+ case *ast.TypeAssertExpr:
+ WriteExpr(buf, x.X)
+ buf.WriteString(".(")
+ WriteExpr(buf, x.Type)
+ buf.WriteByte(')')
+
+ case *ast.CallExpr:
+ WriteExpr(buf, x.Fun)
+ buf.WriteByte('(')
+ writeExprList(buf, x.Args)
+ if x.Ellipsis.IsValid() {
+ buf.WriteString("...")
+ }
+ buf.WriteByte(')')
+
+ case *ast.StarExpr:
+ buf.WriteByte('*')
+ WriteExpr(buf, x.X)
+
+ case *ast.UnaryExpr:
+ buf.WriteString(x.Op.String())
+ WriteExpr(buf, x.X)
+
+ case *ast.BinaryExpr:
+ WriteExpr(buf, x.X)
+ buf.WriteByte(' ')
+ buf.WriteString(x.Op.String())
+ buf.WriteByte(' ')
+ WriteExpr(buf, x.Y)
+
+ case *ast.ArrayType:
+ buf.WriteByte('[')
+ if x.Len != nil {
+ WriteExpr(buf, x.Len)
+ }
+ buf.WriteByte(']')
+ WriteExpr(buf, x.Elt)
+
+ case *ast.StructType:
+ buf.WriteString("struct{")
+ writeFieldList(buf, x.Fields.List, "; ", false)
+ buf.WriteByte('}')
+
+ case *ast.FuncType:
+ buf.WriteString("func")
+ writeSigExpr(buf, x)
+
+ case *ast.InterfaceType:
+ buf.WriteString("interface{")
+ writeFieldList(buf, x.Methods.List, "; ", true)
+ buf.WriteByte('}')
+
+ case *ast.MapType:
+ buf.WriteString("map[")
+ WriteExpr(buf, x.Key)
+ buf.WriteByte(']')
+ WriteExpr(buf, x.Value)
+
+ case *ast.ChanType:
+ var s string
+ switch x.Dir {
+ case ast.SEND:
+ s = "chan<- "
+ case ast.RECV:
+ s = "<-chan "
+ default:
+ s = "chan "
+ }
+ buf.WriteString(s)
+ WriteExpr(buf, x.Value)
+ }
+}
+
+func writeSigExpr(buf *bytes.Buffer, sig *ast.FuncType) {
+ buf.WriteByte('(')
+ writeFieldList(buf, sig.Params.List, ", ", false)
+ buf.WriteByte(')')
+
+ res := sig.Results
+ n := res.NumFields()
+ if n == 0 {
+ // no result
+ return
+ }
+
+ buf.WriteByte(' ')
+ if n == 1 && len(res.List[0].Names) == 0 {
+ // single unnamed result
+ WriteExpr(buf, res.List[0].Type)
+ return
+ }
+
+ // multiple or named result(s)
+ buf.WriteByte('(')
+ writeFieldList(buf, res.List, ", ", false)
+ buf.WriteByte(')')
+}
+
+func writeFieldList(buf *bytes.Buffer, list []*ast.Field, sep string, iface bool) {
+ for i, f := range list {
+ if i > 0 {
+ buf.WriteString(sep)
+ }
+
+ // field list names
+ writeIdentList(buf, f.Names)
+
+ // types of interface methods consist of signatures only
+ if sig, _ := f.Type.(*ast.FuncType); sig != nil && iface {
+ writeSigExpr(buf, sig)
+ continue
+ }
+
+ // named fields are separated with a blank from the field type
+ if len(f.Names) > 0 {
+ buf.WriteByte(' ')
+ }
+
+ WriteExpr(buf, f.Type)
+
+ // ignore tag
+ }
+}
+
+func writeIdentList(buf *bytes.Buffer, list []*ast.Ident) {
+ for i, x := range list {
+ if i > 0 {
+ buf.WriteString(", ")
+ }
+ buf.WriteString(x.Name)
+ }
+}
+
+func writeExprList(buf *bytes.Buffer, list []ast.Expr) {
+ for i, x := range list {
+ if i > 0 {
+ buf.WriteString(", ")
+ }
+ WriteExpr(buf, x)
+ }
+}