| // Copyright 2018 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Package source provides core features for use by Go editors and tools. |
| package source |
| |
| import ( |
| "bytes" |
| "context" |
| "go/ast" |
| "go/format" |
| "go/parser" |
| "go/scanner" |
| "go/token" |
| |
| "golang.org/x/tools/internal/imports" |
| "golang.org/x/tools/internal/lsp/diff" |
| "golang.org/x/tools/internal/lsp/protocol" |
| "golang.org/x/tools/internal/span" |
| "golang.org/x/tools/internal/telemetry/trace" |
| errors "golang.org/x/xerrors" |
| ) |
| |
| // Format formats a file with a given range. |
| func Format(ctx context.Context, snapshot Snapshot, f File) ([]protocol.TextEdit, error) { |
| ctx, done := trace.StartSpan(ctx, "source.Format") |
| defer done() |
| |
| fh := snapshot.Handle(ctx, f) |
| phs, err := snapshot.PackageHandles(ctx, fh) |
| if err != nil { |
| return nil, err |
| } |
| ph, err := NarrowestCheckPackageHandle(phs) |
| if err != nil { |
| return nil, err |
| } |
| pkg, err := ph.Check(ctx) |
| if err != nil { |
| return nil, err |
| } |
| pgh, err := pkg.File(f.URI()) |
| if err != nil { |
| return nil, err |
| } |
| // Be extra careful that the file's ParseMode is correct, |
| // otherwise we might replace the user's code with a trimmed AST. |
| if pgh.Mode() != ParseFull { |
| return nil, errors.Errorf("%s was parsed in the incorrect mode", pgh.File().Identity().URI) |
| } |
| file, m, _, err := pgh.Parse(ctx) |
| if err != nil { |
| return nil, err |
| } |
| if hasListErrors(pkg) || hasParseErrors(pkg, f.URI()) { |
| // Even if this package has list or parse errors, this file may not |
| // have any parse errors and can still be formatted. Using format.Node |
| // on an ast with errors may result in code being added or removed. |
| // Attempt to format the source of this file instead. |
| formatted, err := formatSource(ctx, snapshot, f) |
| if err != nil { |
| return nil, err |
| } |
| return computeTextEdits(ctx, snapshot.View(), pgh.File(), m, string(formatted)) |
| } |
| |
| fset := snapshot.View().Session().Cache().FileSet() |
| buf := &bytes.Buffer{} |
| |
| // format.Node changes slightly from one release to another, so the version |
| // of Go used to build the LSP server will determine how it formats code. |
| // This should be acceptable for all users, who likely be prompted to rebuild |
| // the LSP server on each Go release. |
| if err := format.Node(buf, fset, file); err != nil { |
| return nil, err |
| } |
| return computeTextEdits(ctx, snapshot.View(), pgh.File(), m, buf.String()) |
| } |
| |
| func formatSource(ctx context.Context, s Snapshot, f File) ([]byte, error) { |
| ctx, done := trace.StartSpan(ctx, "source.formatSource") |
| defer done() |
| |
| data, _, err := s.Handle(ctx, f).Read(ctx) |
| if err != nil { |
| return nil, err |
| } |
| return format.Source(data) |
| } |
| |
| type ImportFix struct { |
| Fix *imports.ImportFix |
| Edits []protocol.TextEdit |
| } |
| |
| // AllImportsFixes formats f for each possible fix to the imports. |
| // In addition to returning the result of applying all edits, |
| // it returns a list of fixes that could be applied to the file, with the |
| // corresponding TextEdits that would be needed to apply that fix. |
| func AllImportsFixes(ctx context.Context, snapshot Snapshot, f File) (allFixEdits []protocol.TextEdit, editsPerFix []*ImportFix, err error) { |
| ctx, done := trace.StartSpan(ctx, "source.AllImportsFixes") |
| defer done() |
| |
| fh := snapshot.Handle(ctx, f) |
| phs, err := snapshot.PackageHandles(ctx, fh) |
| if err != nil { |
| return nil, nil, err |
| } |
| ph, err := NarrowestCheckPackageHandle(phs) |
| if err != nil { |
| return nil, nil, err |
| } |
| pkg, err := ph.Check(ctx) |
| if err != nil { |
| return nil, nil, err |
| } |
| if hasListErrors(pkg) { |
| return nil, nil, errors.Errorf("%s has list errors, not running goimports", f.URI()) |
| } |
| pgh, err := pkg.File(f.URI()) |
| if err != nil { |
| return nil, nil, err |
| } |
| options := &imports.Options{ |
| // Defaults. |
| AllErrors: true, |
| Comments: true, |
| Fragment: true, |
| FormatOnly: false, |
| TabIndent: true, |
| TabWidth: 8, |
| } |
| err = snapshot.View().RunProcessEnvFunc(ctx, func(opts *imports.Options) error { |
| allFixEdits, editsPerFix, err = computeImportEdits(ctx, snapshot.View(), pgh, opts) |
| return err |
| }, options) |
| if err != nil { |
| return nil, nil, err |
| } |
| |
| return allFixEdits, editsPerFix, nil |
| } |
| |
| // computeImportEdits computes a set of edits that perform one or all of the |
| // necessary import fixes. |
| func computeImportEdits(ctx context.Context, view View, ph ParseGoHandle, options *imports.Options) (allFixEdits []protocol.TextEdit, editsPerFix []*ImportFix, err error) { |
| filename := ph.File().Identity().URI.Filename() |
| |
| // Build up basic information about the original file. |
| origData, _, err := ph.File().Read(ctx) |
| if err != nil { |
| return nil, nil, err |
| } |
| origAST, origMapper, _, err := ph.Parse(ctx) |
| if err != nil { |
| return nil, nil, err |
| } |
| origImports, origImportOffset := trimToImports(view.Session().Cache().FileSet(), origAST, origData) |
| |
| allFixes, err := imports.FixImports(filename, origData, options) |
| if err != nil { |
| return nil, nil, err |
| } |
| |
| allFixEdits, err = computeFixEdits(view, ph, options, origData, origAST, origMapper, origImports, origImportOffset, allFixes) |
| if err != nil { |
| return nil, nil, err |
| } |
| |
| // Apply all of the import fixes to the file. |
| // Add the edits for each fix to the result. |
| for _, fix := range allFixes { |
| edits, err := computeFixEdits(view, ph, options, origData, origAST, origMapper, origImports, origImportOffset, []*imports.ImportFix{fix}) |
| if err != nil { |
| return nil, nil, err |
| } |
| editsPerFix = append(editsPerFix, &ImportFix{ |
| Fix: fix, |
| Edits: edits, |
| }) |
| } |
| return allFixEdits, editsPerFix, nil |
| } |
| |
| func computeOneImportFixEdits(ctx context.Context, view View, ph ParseGoHandle, fix *imports.ImportFix) ([]protocol.TextEdit, error) { |
| origData, _, err := ph.File().Read(ctx) |
| if err != nil { |
| return nil, err |
| } |
| origAST, origMapper, _, err := ph.Parse(ctx) |
| if err != nil { |
| return nil, err |
| } |
| origImports, origImportOffset := trimToImports(view.Session().Cache().FileSet(), origAST, origData) |
| |
| options := &imports.Options{ |
| // Defaults. |
| AllErrors: true, |
| Comments: true, |
| Fragment: true, |
| FormatOnly: false, |
| TabIndent: true, |
| TabWidth: 8, |
| } |
| return computeFixEdits(view, ph, options, origData, origAST, origMapper, origImports, origImportOffset, []*imports.ImportFix{fix}) |
| } |
| |
| func computeFixEdits(view View, ph ParseGoHandle, options *imports.Options, origData []byte, origAST *ast.File, origMapper *protocol.ColumnMapper, origImports []byte, origImportOffset int, fixes []*imports.ImportFix) ([]protocol.TextEdit, error) { |
| filename := ph.File().Identity().URI.Filename() |
| // Apply the fixes and re-parse the file so that we can locate the |
| // new imports. |
| fixedData, err := imports.ApplyFixes(fixes, filename, origData, options) |
| if err != nil { |
| return nil, err |
| } |
| fixedFset := token.NewFileSet() |
| fixedAST, err := parser.ParseFile(fixedFset, filename, fixedData, parser.ImportsOnly) |
| // Any error here prevents us from computing the edits. |
| if err != nil { |
| return nil, err |
| } |
| fixedImports, fixedImportsOffset := trimToImports(fixedFset, fixedAST, fixedData) |
| |
| // Prepare the diff. If both sides had import statements, we can diff |
| // just those sections against each other, then shift the resulting |
| // edits to the right lines in the original file. |
| left, right := origImports, fixedImports |
| converter := span.NewContentConverter(filename, origImports) |
| offset := origImportOffset |
| |
| // If one side or the other has no imports, we won't know where to |
| // anchor the diffs. Instead, use the beginning of the file, up to its |
| // first non-imports decl. We know the imports code will insert |
| // somewhere before that. |
| if origImportOffset == 0 || fixedImportsOffset == 0 { |
| left, _ = trimToFirstNonImport(view.Session().Cache().FileSet(), origAST, origData, nil) |
| // We need the whole AST here, not just the ImportsOnly AST we parsed above. |
| fixedAST, err = parser.ParseFile(fixedFset, filename, fixedData, 0) |
| if fixedAST == nil { |
| return nil, err |
| } |
| var ok bool |
| right, ok = trimToFirstNonImport(fixedFset, fixedAST, fixedData, err) |
| if !ok { |
| return nil, errors.Errorf("error %v detected in the import block", err) |
| } |
| // We're now working with a prefix of the original file, so we can |
| // use the original converter, and there is no offset on the edits. |
| converter = origMapper.Converter |
| offset = 0 |
| } |
| |
| // Perform the diff and adjust the results for the trimming, if any. |
| edits := view.Options().ComputeEdits(ph.File().Identity().URI, string(left), string(right)) |
| for i := range edits { |
| s, err := edits[i].Span.WithPosition(converter) |
| if err != nil { |
| return nil, err |
| } |
| start := span.NewPoint(s.Start().Line()+offset, s.Start().Column(), -1) |
| end := span.NewPoint(s.End().Line()+offset, s.End().Column(), -1) |
| edits[i].Span = span.New(s.URI(), start, end) |
| } |
| return ToProtocolEdits(origMapper, edits) |
| } |
| |
| // trimToImports returns a section of the source file that covers all of the |
| // import declarations, and the line offset into the file that section starts at. |
| func trimToImports(fset *token.FileSet, f *ast.File, src []byte) ([]byte, int) { |
| var firstImport, lastImport ast.Decl |
| for _, decl := range f.Decls { |
| if gen, ok := decl.(*ast.GenDecl); ok && gen.Tok == token.IMPORT { |
| if firstImport == nil { |
| firstImport = decl |
| } |
| lastImport = decl |
| } |
| } |
| |
| if firstImport == nil { |
| return nil, 0 |
| } |
| tok := fset.File(f.Pos()) |
| start := firstImport.Pos() |
| end := lastImport.End() |
| if tok.LineCount() > fset.Position(end).Line { |
| end = fset.File(f.Pos()).LineStart(fset.Position(lastImport.End()).Line + 1) |
| } |
| |
| startLineOffset := fset.Position(start).Line - 1 // lines are 1-indexed. |
| return src[fset.Position(firstImport.Pos()).Offset:fset.Position(end).Offset], startLineOffset |
| } |
| |
| // trimToFirstNonImport returns src from the beginning to the first non-import |
| // declaration, or the end of the file if there is no such decl. |
| func trimToFirstNonImport(fset *token.FileSet, f *ast.File, src []byte, err error) ([]byte, bool) { |
| var firstDecl ast.Decl |
| for _, decl := range f.Decls { |
| if gen, ok := decl.(*ast.GenDecl); ok && gen.Tok == token.IMPORT { |
| continue |
| } |
| firstDecl = decl |
| break |
| } |
| tok := fset.File(f.Pos()) |
| if tok == nil { |
| return nil, false |
| } |
| end := f.End() |
| if firstDecl != nil { |
| if firstDeclLine := fset.Position(firstDecl.Pos()).Line; firstDeclLine > 1 { |
| end = tok.LineStart(firstDeclLine - 1) |
| } |
| } |
| // Any errors in the file must be after the part of the file that we care about. |
| switch err := err.(type) { |
| case *scanner.Error: |
| pos := tok.Pos(err.Pos.Offset) |
| if pos <= end { |
| return nil, false |
| } |
| case scanner.ErrorList: |
| if err.Len() > 0 { |
| pos := tok.Pos(err[0].Pos.Offset) |
| if pos <= end { |
| return nil, false |
| } |
| } |
| } |
| return src[0:fset.Position(end).Offset], true |
| } |
| |
| // CandidateImports returns every import that could be added to filename. |
| func CandidateImports(ctx context.Context, view View, filename string) ([]imports.ImportFix, error) { |
| ctx, done := trace.StartSpan(ctx, "source.CandidateImports") |
| defer done() |
| |
| options := &imports.Options{ |
| // Defaults. |
| AllErrors: true, |
| Comments: true, |
| Fragment: true, |
| FormatOnly: false, |
| TabIndent: true, |
| TabWidth: 8, |
| } |
| |
| var imps []imports.ImportFix |
| importFn := func(opts *imports.Options) error { |
| var err error |
| imps, err = imports.GetAllCandidates(filename, opts) |
| return err |
| } |
| err := view.RunProcessEnvFunc(ctx, importFn, options) |
| return imps, err |
| } |
| |
| // PackageExports returns all the packages named pkg that could be imported by |
| // filename, and their exports. |
| func PackageExports(ctx context.Context, view View, pkg, filename string) ([]imports.PackageExport, error) { |
| ctx, done := trace.StartSpan(ctx, "source.PackageExports") |
| defer done() |
| |
| options := &imports.Options{ |
| // Defaults. |
| AllErrors: true, |
| Comments: true, |
| Fragment: true, |
| FormatOnly: false, |
| TabIndent: true, |
| TabWidth: 8, |
| } |
| |
| var pkgs []imports.PackageExport |
| importFn := func(opts *imports.Options) error { |
| var err error |
| pkgs, err = imports.GetPackageExports(pkg, filename, opts) |
| return err |
| } |
| err := view.RunProcessEnvFunc(ctx, importFn, options) |
| return pkgs, err |
| } |
| |
| // hasParseErrors returns true if the given file has parse errors. |
| func hasParseErrors(pkg Package, uri span.URI) bool { |
| for _, e := range pkg.GetErrors() { |
| if e.File.URI == uri && e.Kind == ParseError { |
| return true |
| } |
| } |
| return false |
| } |
| |
| func hasListErrors(pkg Package) bool { |
| for _, err := range pkg.GetErrors() { |
| if err.Kind == ListError { |
| return true |
| } |
| } |
| return false |
| } |
| |
| func computeTextEdits(ctx context.Context, view View, fh FileHandle, m *protocol.ColumnMapper, formatted string) ([]protocol.TextEdit, error) { |
| ctx, done := trace.StartSpan(ctx, "source.computeTextEdits") |
| defer done() |
| |
| data, _, err := fh.Read(ctx) |
| if err != nil { |
| return nil, err |
| } |
| edits := view.Options().ComputeEdits(fh.Identity().URI, string(data), formatted) |
| return ToProtocolEdits(m, edits) |
| } |
| |
| func ToProtocolEdits(m *protocol.ColumnMapper, edits []diff.TextEdit) ([]protocol.TextEdit, error) { |
| if edits == nil { |
| return nil, nil |
| } |
| result := make([]protocol.TextEdit, len(edits)) |
| for i, edit := range edits { |
| rng, err := m.Range(edit.Span) |
| if err != nil { |
| return nil, err |
| } |
| result[i] = protocol.TextEdit{ |
| Range: rng, |
| NewText: edit.NewText, |
| } |
| } |
| return result, nil |
| } |
| |
| func FromProtocolEdits(m *protocol.ColumnMapper, edits []protocol.TextEdit) ([]diff.TextEdit, error) { |
| if edits == nil { |
| return nil, nil |
| } |
| result := make([]diff.TextEdit, len(edits)) |
| for i, edit := range edits { |
| spn, err := m.RangeSpan(edit.Range) |
| if err != nil { |
| return nil, err |
| } |
| result[i] = diff.TextEdit{ |
| Span: spn, |
| NewText: edit.NewText, |
| } |
| } |
| return result, nil |
| } |