internal/lsp/source/format.go - tools - Git at Google

 // 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
 }
	// 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
	}