diff --git a/gopls/internal/lsp/cache/analysis.go b/gopls/internal/lsp/cache/analysis.go
index 61e868c..8bbe2ed 100644
--- a/gopls/internal/lsp/cache/analysis.go
+++ b/gopls/internal/lsp/cache/analysis.go
@@ -1024,7 +1024,7 @@
 				if end == token.NoPos {
 					end = start
 				}
-				rng, err := p.Mapper.PosRange(start, end)
+				rng, err := p.PosRange(start, end)
 				if err != nil {
 					return protocol.Location{}, err
 				}
diff --git a/gopls/internal/lsp/cache/check.go b/gopls/internal/lsp/cache/check.go
index cfac5ff..c52a2f8 100644
--- a/gopls/internal/lsp/cache/check.go
+++ b/gopls/internal/lsp/cache/check.go
@@ -683,7 +683,7 @@
 			}
 
 			for _, imp := range allImports[item] {
-				rng, err := source.NewMappedRange(imp.cgf.Mapper, imp.imp.Pos(), imp.imp.End()).Range()
+				rng, err := imp.cgf.PosRange(imp.imp.Pos(), imp.imp.End())
 				if err != nil {
 					return nil, err
 				}
diff --git a/gopls/internal/lsp/cache/errors.go b/gopls/internal/lsp/cache/errors.go
index 7ca4f07..6777193 100644
--- a/gopls/internal/lsp/cache/errors.go
+++ b/gopls/internal/lsp/cache/errors.go
@@ -86,17 +86,12 @@
 	if err != nil {
 		return nil, err
 	}
-	pos := pgf.Tok.Pos(e.Pos.Offset)
-	spn, err := span.NewRange(pgf.Tok, pos, pos).Span()
-	if err != nil {
-		return nil, err
-	}
-	rng, err := spanToRange(pkg, spn)
+	rng, err := pgf.Mapper.OffsetRange(e.Pos.Offset, e.Pos.Offset)
 	if err != nil {
 		return nil, err
 	}
 	return []*source.Diagnostic{{
-		URI:      spn.URI(),
+		URI:      pgf.URI,
 		Range:    rng,
 		Severity: protocol.SeverityError,
 		Source:   source.ParseError,
@@ -327,7 +322,7 @@
 	if !end.IsValid() || end == start {
 		end = analysisinternal.TypeErrorEndPos(fset, pgf.Src, start)
 	}
-	spn, err := span.FileSpan(pgf.Mapper.TokFile, start, end)
+	spn, err := span.FileSpan(pgf.Tok, start, end)
 	if err != nil {
 		return 0, span.Span{}, err
 	}
@@ -379,7 +374,11 @@
 		// Search file imports for the import that is causing the import cycle.
 		for _, imp := range cgf.File.Imports {
 			if imp.Path.Value == circImp {
-				spn, err := span.NewRange(cgf.Tok, imp.Pos(), imp.End()).Span()
+				start, end, err := safetoken.Offsets(cgf.Tok, imp.Pos(), imp.End())
+				if err != nil {
+					return msg, span.Span{}, false
+				}
+				spn, err := cgf.Mapper.OffsetSpan(start, end)
 				if err != nil {
 					return msg, span.Span{}, false
 				}
diff --git a/gopls/internal/lsp/cache/load.go b/gopls/internal/lsp/cache/load.go
index f79109a..b072aaf 100644
--- a/gopls/internal/lsp/cache/load.go
+++ b/gopls/internal/lsp/cache/load.go
@@ -391,10 +391,7 @@
 			if pgf, err := s.ParseGo(ctx, fh, source.ParseHeader); err == nil {
 				// Check that we have a valid `package foo` range to use for positioning the error.
 				if pgf.File.Package.IsValid() && pgf.File.Name != nil && pgf.File.Name.End().IsValid() {
-					pkgDecl := span.NewRange(pgf.Tok, pgf.File.Package, pgf.File.Name.End())
-					if spn, err := pkgDecl.Span(); err == nil {
-						rng, _ = pgf.Mapper.Range(spn)
-					}
+					rng, _ = pgf.PosRange(pgf.File.Package, pgf.File.Name.End())
 				}
 			}
 		case source.Mod:
diff --git a/gopls/internal/lsp/cache/mod.go b/gopls/internal/lsp/cache/mod.go
index 757bb5e..a3d207d 100644
--- a/gopls/internal/lsp/cache/mod.go
+++ b/gopls/internal/lsp/cache/mod.go
@@ -402,11 +402,12 @@
 		if pm.File.Module == nil {
 			return span.New(pm.URI, span.NewPoint(1, 1, 0), span.Point{}), false, nil
 		}
-		spn, err := spanFromPositions(pm.Mapper, pm.File.Module.Syntax.Start, pm.File.Module.Syntax.End)
+		syntax := pm.File.Module.Syntax
+		spn, err := pm.Mapper.OffsetSpan(syntax.Start.Byte, syntax.End.Byte)
 		return spn, false, err
 	}
 
-	spn, err := spanFromPositions(pm.Mapper, reference.Start, reference.End)
+	spn, err := pm.Mapper.OffsetSpan(reference.Start.Byte, reference.End.Byte)
 	return spn, true, err
 }
 
diff --git a/gopls/internal/lsp/cache/mod_tidy.go b/gopls/internal/lsp/cache/mod_tidy.go
index fa30df1..c9c02ca 100644
--- a/gopls/internal/lsp/cache/mod_tidy.go
+++ b/gopls/internal/lsp/cache/mod_tidy.go
@@ -8,7 +8,6 @@
 	"context"
 	"fmt"
 	"go/ast"
-	"go/token"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -263,7 +262,7 @@
 				if !ok {
 					return nil, fmt.Errorf("no missing module fix for %q (%q)", importPath, req.Mod.Path)
 				}
-				srcErr, err := missingModuleForImport(pgf.Tok, m, imp, req, fixes)
+				srcErr, err := missingModuleForImport(pgf, imp, req, fixes)
 				if err != nil {
 					return nil, err
 				}
@@ -423,16 +422,16 @@
 
 // missingModuleForImport creates an error for a given import path that comes
 // from a missing module.
-func missingModuleForImport(file *token.File, m *protocol.ColumnMapper, imp *ast.ImportSpec, req *modfile.Require, fixes []source.SuggestedFix) (*source.Diagnostic, error) {
+func missingModuleForImport(pgf *source.ParsedGoFile, imp *ast.ImportSpec, req *modfile.Require, fixes []source.SuggestedFix) (*source.Diagnostic, error) {
 	if req.Syntax == nil {
 		return nil, fmt.Errorf("no syntax for %v", req)
 	}
-	rng, err := m.PosRange(imp.Path.Pos(), imp.Path.End())
+	rng, err := pgf.PosRange(imp.Path.Pos(), imp.Path.End())
 	if err != nil {
 		return nil, err
 	}
 	return &source.Diagnostic{
-		URI:            m.URI,
+		URI:            pgf.URI,
 		Range:          rng,
 		Severity:       protocol.SeverityError,
 		Source:         source.ModTidyError,
@@ -441,25 +440,6 @@
 	}, nil
 }
 
-func spanFromPositions(m *protocol.ColumnMapper, s, e modfile.Position) (span.Span, error) {
-	toPoint := func(offset int) (span.Point, error) {
-		l, c, err := span.ToPosition(m.TokFile, offset)
-		if err != nil {
-			return span.Point{}, err
-		}
-		return span.NewPoint(l, c, offset), nil
-	}
-	start, err := toPoint(s.Byte)
-	if err != nil {
-		return span.Span{}, err
-	}
-	end, err := toPoint(e.Byte)
-	if err != nil {
-		return span.Span{}, err
-	}
-	return span.New(m.URI, start, end), nil
-}
-
 // parseImports parses the headers of the specified files and returns
 // the set of strings that appear in import declarations within
 // GoFiles. Errors are ignored.
diff --git a/gopls/internal/lsp/cache/parse.go b/gopls/internal/lsp/cache/parse.go
index 83f18da..7451cc3 100644
--- a/gopls/internal/lsp/cache/parse.go
+++ b/gopls/internal/lsp/cache/parse.go
@@ -202,17 +202,13 @@
 	}
 
 	return &source.ParsedGoFile{
-		URI:   fh.URI(),
-		Mode:  mode,
-		Src:   src,
-		Fixed: fixed,
-		File:  file,
-		Tok:   tok,
-		Mapper: &protocol.ColumnMapper{
-			URI:     fh.URI(),
-			TokFile: tok,
-			Content: src,
-		},
+		URI:      fh.URI(),
+		Mode:     mode,
+		Src:      src,
+		Fixed:    fixed,
+		File:     file,
+		Tok:      tok,
+		Mapper:   protocol.NewColumnMapper(fh.URI(), src),
 		ParseErr: parseErr,
 	}, nil
 }
@@ -900,11 +896,7 @@
 	}
 
 	// Try to extract a statement from the BadExpr.
-	start, err := safetoken.Offset(tok, bad.Pos())
-	if err != nil {
-		return
-	}
-	end, err := safetoken.Offset(tok, bad.End()-1)
+	start, end, err := safetoken.Offsets(tok, bad.Pos(), bad.End()-1)
 	if err != nil {
 		return
 	}
@@ -989,11 +981,7 @@
 	// Avoid doing tok.Offset(to) since that panics if badExpr ends at EOF.
 	// It also panics if the position is not in the range of the file, and
 	// badExprs may not necessarily have good positions, so check first.
-	fromOffset, err := safetoken.Offset(tok, from)
-	if err != nil {
-		return false
-	}
-	toOffset, err := safetoken.Offset(tok, to-1)
+	fromOffset, toOffset, err := safetoken.Offsets(tok, from, to-1)
 	if err != nil {
 		return false
 	}
@@ -1150,18 +1138,13 @@
 		}
 	}
 
-	fromOffset, err := safetoken.Offset(tok, from)
+	fromOffset, toOffset, err := safetoken.Offsets(tok, from, to)
 	if err != nil {
 		return false
 	}
 	if !from.IsValid() || fromOffset >= len(src) {
 		return false
 	}
-
-	toOffset, err := safetoken.Offset(tok, to)
-	if err != nil {
-		return false
-	}
 	if !to.IsValid() || toOffset >= len(src) {
 		return false
 	}
diff --git a/gopls/internal/lsp/cmd/cmd.go b/gopls/internal/lsp/cmd/cmd.go
index 3aa74d0..c221913 100644
--- a/gopls/internal/lsp/cmd/cmd.go
+++ b/gopls/internal/lsp/cmd/cmd.go
@@ -11,7 +11,6 @@
 	"context"
 	"flag"
 	"fmt"
-	"go/token"
 	"io/ioutil"
 	"log"
 	"os"
@@ -385,8 +384,7 @@
 
 type cmdClient struct {
 	protocol.Server
-	app  *Application
-	fset *token.FileSet
+	app *Application
 
 	diagnosticsMu   sync.Mutex
 	diagnosticsDone chan struct{}
@@ -407,7 +405,6 @@
 	return &connection{
 		Client: &cmdClient{
 			app:   app,
-			fset:  token.NewFileSet(),
 			files: make(map[span.URI]*cmdFile),
 		},
 	}
@@ -541,19 +538,12 @@
 		c.files[uri] = file
 	}
 	if file.mapper == nil {
-		fname := uri.Filename()
-		content, err := ioutil.ReadFile(fname)
+		content, err := ioutil.ReadFile(uri.Filename())
 		if err != nil {
 			file.err = fmt.Errorf("getFile: %v: %v", uri, err)
 			return file
 		}
-		f := c.fset.AddFile(fname, -1, len(content))
-		f.SetLinesForContent(content)
-		file.mapper = &protocol.ColumnMapper{
-			URI:     uri,
-			TokFile: f,
-			Content: content,
-		}
+		file.mapper = protocol.NewColumnMapper(uri, content)
 	}
 	return file
 }
diff --git a/gopls/internal/lsp/code_action.go b/gopls/internal/lsp/code_action.go
index 0767d43..5e0a778 100644
--- a/gopls/internal/lsp/code_action.go
+++ b/gopls/internal/lsp/code_action.go
@@ -316,7 +316,7 @@
 	if err != nil {
 		return nil, fmt.Errorf("getting file for Identifier: %w", err)
 	}
-	srng, err := pgf.Mapper.RangeToSpanRange(rng)
+	srng, err := pgf.RangeToSpanRange(rng)
 	if err != nil {
 		return nil, err
 	}
diff --git a/gopls/internal/lsp/completion.go b/gopls/internal/lsp/completion.go
index c967c1f..e443a3c 100644
--- a/gopls/internal/lsp/completion.go
+++ b/gopls/internal/lsp/completion.go
@@ -60,6 +60,8 @@
 	// internal/span, as the latter treats end of file as the beginning of the
 	// next line, even when it's not newline-terminated. See golang/go#41029 for
 	// more details.
+	// TODO(adonovan): make completion retain the pgf.Mapper
+	// so we can convert to rng without reading.
 	src, err := fh.Read()
 	if err != nil {
 		return nil, err
diff --git a/gopls/internal/lsp/definition.go b/gopls/internal/lsp/definition.go
index d2ad474..d83512a 100644
--- a/gopls/internal/lsp/definition.go
+++ b/gopls/internal/lsp/definition.go
@@ -58,13 +58,13 @@
 	if ident.Type.Object == nil {
 		return nil, fmt.Errorf("no type definition for %s", ident.Name)
 	}
-	identRange, err := ident.Type.Range()
+	identRange, err := ident.Type.MappedRange.Range()
 	if err != nil {
 		return nil, err
 	}
 	return []protocol.Location{
 		{
-			URI:   protocol.URIFromSpanURI(ident.Type.URI()),
+			URI:   protocol.URIFromSpanURI(ident.Type.MappedRange.URI()),
 			Range: identRange,
 		},
 	}, nil
diff --git a/gopls/internal/lsp/diagnostics.go b/gopls/internal/lsp/diagnostics.go
index 863c142..6ec7a08 100644
--- a/gopls/internal/lsp/diagnostics.go
+++ b/gopls/internal/lsp/diagnostics.go
@@ -577,7 +577,7 @@
 	if !pgf.File.Name.Pos().IsValid() {
 		return nil
 	}
-	rng, err := pgf.Mapper.PosRange(pgf.File.Name.Pos(), pgf.File.Name.End())
+	rng, err := pgf.PosRange(pgf.File.Name.Pos(), pgf.File.Name.End())
 	if err != nil {
 		return nil
 	}
diff --git a/gopls/internal/lsp/folding_range.go b/gopls/internal/lsp/folding_range.go
index 4a2d828..86469d3 100644
--- a/gopls/internal/lsp/folding_range.go
+++ b/gopls/internal/lsp/folding_range.go
@@ -28,7 +28,7 @@
 func toProtocolFoldingRanges(ranges []*source.FoldingRangeInfo) ([]protocol.FoldingRange, error) {
 	result := make([]protocol.FoldingRange, 0, len(ranges))
 	for _, info := range ranges {
-		rng, err := info.Range()
+		rng, err := info.MappedRange.Range()
 		if err != nil {
 			return nil, err
 		}
diff --git a/gopls/internal/lsp/link.go b/gopls/internal/lsp/link.go
index 011f0e4..e7bdb60 100644
--- a/gopls/internal/lsp/link.go
+++ b/gopls/internal/lsp/link.go
@@ -17,8 +17,8 @@
 
 	"golang.org/x/mod/modfile"
 	"golang.org/x/tools/gopls/internal/lsp/protocol"
+	"golang.org/x/tools/gopls/internal/lsp/safetoken"
 	"golang.org/x/tools/gopls/internal/lsp/source"
-	"golang.org/x/tools/gopls/internal/span"
 	"golang.org/x/tools/internal/event"
 	"golang.org/x/tools/internal/event/tag"
 )
@@ -48,7 +48,6 @@
 	if err != nil {
 		return nil, err
 	}
-	tokFile := pm.Mapper.TokFile
 
 	var links []protocol.DocumentLink
 	for _, req := range pm.File.Require {
@@ -60,16 +59,15 @@
 			continue
 		}
 		dep := []byte(req.Mod.Path)
-		s, e := req.Syntax.Start.Byte, req.Syntax.End.Byte
-		i := bytes.Index(pm.Mapper.Content[s:e], dep)
+		start, end := req.Syntax.Start.Byte, req.Syntax.End.Byte
+		i := bytes.Index(pm.Mapper.Content[start:end], dep)
 		if i == -1 {
 			continue
 		}
 		// Shift the start position to the location of the
 		// dependency within the require statement.
-		start, end := tokFile.Pos(s+i), tokFile.Pos(s+i+len(dep))
 		target := source.BuildLink(snapshot.View().Options().LinkTarget, "mod/"+req.Mod.String(), "")
-		l, err := toProtocolLink(tokFile, pm.Mapper, target, start, end)
+		l, err := toProtocolLink(pm.Mapper, target, start+i, start+i+len(dep))
 		if err != nil {
 			return nil, err
 		}
@@ -89,8 +87,7 @@
 		}
 		for _, section := range [][]modfile.Comment{comments.Before, comments.Suffix, comments.After} {
 			for _, comment := range section {
-				start := tokFile.Pos(comment.Start.Byte)
-				l, err := findLinksInString(urlRegexp, comment.Token, start, tokFile, pm.Mapper)
+				l, err := findLinksInString(urlRegexp, comment.Token, comment.Start.Byte, pm.Mapper)
 				if err != nil {
 					return nil, err
 				}
@@ -145,11 +142,13 @@
 				urlPath = strings.Replace(urlPath, m.Module.Path, m.Module.Path+"@"+m.Module.Version, 1)
 			}
 
-			// Account for the quotation marks in the positions.
-			start := imp.Path.Pos() + 1
-			end := imp.Path.End() - 1
+			start, end, err := safetoken.Offsets(pgf.Tok, imp.Path.Pos(), imp.Path.End())
+			if err != nil {
+				return nil, err
+			}
 			targetURL := source.BuildLink(view.Options().LinkTarget, urlPath, "")
-			l, err := toProtocolLink(pgf.Tok, pgf.Mapper, targetURL, start, end)
+			// Account for the quotation marks in the positions.
+			l, err := toProtocolLink(pgf.Mapper, targetURL, start+len(`"`), end-len(`"`))
 			if err != nil {
 				return nil, err
 			}
@@ -173,7 +172,11 @@
 		return true
 	})
 	for _, s := range str {
-		l, err := findLinksInString(urlRegexp, s.Value, s.Pos(), pgf.Tok, pgf.Mapper)
+		strOffset, err := safetoken.Offset(pgf.Tok, s.Pos())
+		if err != nil {
+			return nil, err
+		}
+		l, err := findLinksInString(urlRegexp, s.Value, strOffset, pgf.Mapper)
 		if err != nil {
 			return nil, err
 		}
@@ -183,7 +186,11 @@
 	// Gather links found in comments.
 	for _, commentGroup := range pgf.File.Comments {
 		for _, comment := range commentGroup.List {
-			l, err := findLinksInString(urlRegexp, comment.Text, comment.Pos(), pgf.Tok, pgf.Mapper)
+			commentOffset, err := safetoken.Offset(pgf.Tok, comment.Pos())
+			if err != nil {
+				return nil, err
+			}
+			l, err := findLinksInString(urlRegexp, comment.Text, commentOffset, pgf.Mapper)
 			if err != nil {
 				return nil, err
 			}
@@ -203,13 +210,11 @@
 }
 
 // urlRegexp is the user-supplied regular expression to match URL.
-// tokFile may be a throwaway File for non-Go files.
-func findLinksInString(urlRegexp *regexp.Regexp, src string, pos token.Pos, tokFile *token.File, m *protocol.ColumnMapper) ([]protocol.DocumentLink, error) {
+// srcOffset is the start offset of 'src' within m's file.
+func findLinksInString(urlRegexp *regexp.Regexp, src string, srcOffset int, m *protocol.ColumnMapper) ([]protocol.DocumentLink, error) {
 	var links []protocol.DocumentLink
 	for _, index := range urlRegexp.FindAllIndex([]byte(src), -1) {
 		start, end := index[0], index[1]
-		startPos := token.Pos(int(pos) + start)
-		endPos := token.Pos(int(pos) + end)
 		link := src[start:end]
 		linkURL, err := url.Parse(link)
 		// Fallback: Linkify IP addresses as suggested in golang/go#18824.
@@ -227,7 +232,8 @@
 		if !acceptedSchemes[linkURL.Scheme] {
 			continue
 		}
-		l, err := toProtocolLink(tokFile, m, linkURL.String(), startPos, endPos)
+
+		l, err := toProtocolLink(m, linkURL.String(), srcOffset+start, srcOffset+end)
 		if err != nil {
 			return nil, err
 		}
@@ -237,15 +243,13 @@
 	r := getIssueRegexp()
 	for _, index := range r.FindAllIndex([]byte(src), -1) {
 		start, end := index[0], index[1]
-		startPos := token.Pos(int(pos) + start)
-		endPos := token.Pos(int(pos) + end)
 		matches := r.FindStringSubmatch(src)
 		if len(matches) < 4 {
 			continue
 		}
 		org, repo, number := matches[1], matches[2], matches[3]
 		targetURL := fmt.Sprintf("https://github.com/%s/%s/issues/%s", org, repo, number)
-		l, err := toProtocolLink(tokFile, m, targetURL, startPos, endPos)
+		l, err := toProtocolLink(m, targetURL, srcOffset+start, srcOffset+end)
 		if err != nil {
 			return nil, err
 		}
@@ -266,12 +270,8 @@
 	issueRegexp *regexp.Regexp
 )
 
-func toProtocolLink(tokFile *token.File, m *protocol.ColumnMapper, targetURL string, start, end token.Pos) (protocol.DocumentLink, error) {
-	spn, err := span.NewRange(tokFile, start, end).Span()
-	if err != nil {
-		return protocol.DocumentLink{}, err
-	}
-	rng, err := m.Range(spn)
+func toProtocolLink(m *protocol.ColumnMapper, targetURL string, start, end int) (protocol.DocumentLink, error) {
+	rng, err := m.OffsetRange(start, end)
 	if err != nil {
 		return protocol.DocumentLink{}, err
 	}
diff --git a/gopls/internal/lsp/protocol/span.go b/gopls/internal/lsp/protocol/span.go
index 78e180c..160b925 100644
--- a/gopls/internal/lsp/protocol/span.go
+++ b/gopls/internal/lsp/protocol/span.go
@@ -8,12 +8,12 @@
 //
 // Imports: source  --> lsppos  -->  protocol  -->  span  -->  token
 //
-// source.MappedRange = (span.Range, protocol.ColumnMapper)
+// source.MappedRange = (*ParsedGoFile, start/end token.Pos)
 //
 // lsppos.TokenMapper = (token.File, lsppos.Mapper)
 // lsppos.Mapper = (line offset table, content)
 //
-// protocol.ColumnMapper = (URI, token.File, content)
+// protocol.ColumnMapper = (URI, Content). Does all offset <=> column conversions.
 // protocol.Location = (URI, protocol.Range)
 // protocol.Range = (start, end Position)
 // protocol.Position = (line, char uint32) 0-based UTF-16
@@ -24,12 +24,19 @@
 //
 // token.Pos
 // token.FileSet
+// token.File
 // offset int
 //
-// TODO(adonovan): simplify this picture. Eliminate the optionality of
-// span.{Span,Point}'s position and offset fields: work internally in
-// terms of offsets (like span.Range), and require a mapper to convert
-// them to protocol (UTF-16) line/col form.
+// TODO(adonovan): simplify this picture:
+//   - Eliminate the optionality of span.{Span,Point}'s position and offset fields?
+//   - Move span.Range to package safetoken. Can we eliminate it?
+//     Without a ColumnMapper it's not really self-contained.
+//     It is mostly used by completion. Given access to complete.mapper,
+//     it could use a pair byte offsets instead.
+//   - Merge lsppos.Mapper and protocol.ColumnMapper.
+//   - Replace all uses of lsppos.TokenMapper by the underlying ParsedGoFile,
+//     which carries a token.File and a ColumnMapper.
+//   - Then delete lsppos package.
 
 package protocol
 
@@ -41,35 +48,52 @@
 	"strings"
 	"unicode/utf8"
 
-	"golang.org/x/tools/gopls/internal/lsp/safetoken"
 	"golang.org/x/tools/gopls/internal/span"
 	"golang.org/x/tools/internal/bug"
 )
 
-// A ColumnMapper maps between UTF-8 oriented positions (e.g. token.Pos,
-// span.Span) and the UTF-16 oriented positions used by the LSP.
+// A ColumnMapper wraps the content of a file and provides mapping
+// from byte offsets to and from other notations of position:
+//
+//   - (line, col8) pairs, where col8 is a 1-based UTF-8 column number (bytes),
+//     as used by go/token;
+//
+//   - (line, col16) pairs, where col16 is a 1-based UTF-16 column number,
+//     as used by the LSP protocol;
+//
+//   - (line, colRune) pairs, where colRune is a rune index, as used by ParseWork.
+//
+// This type does not depend on or use go/token-based representations.
+// Use safetoken to map between token.Pos <=> byte offsets.
 type ColumnMapper struct {
 	URI     span.URI
-	TokFile *token.File
 	Content []byte
 
-	// File content is only really needed for UTF-16 column
-	// computation, which could be be achieved more compactly.
-	// For example, one could record only the lines for which
-	// UTF-16 columns differ from the UTF-8 ones, or only the
-	// indices of the non-ASCII characters.
+	// This field provides a line-number table, nothing more.
+	// The public API of ColumnMapper doesn't mention go/token,
+	// nor should it. It need not be consistent with any
+	// other token.File or FileSet.
 	//
-	// TODO(adonovan): consider not retaining the entire file
-	// content, or at least not exposing the fact that we
-	// currently retain it.
+	// TODO(adonovan): eliminate this field in a follow-up
+	// by inlining the line-number table. Then merge this
+	// type with the nearly identical lsspos.Mapper.
+	//
+	// TODO(adonovan): opt: quick experiments suggest that
+	// ColumnMappers are created for thousands of files but the
+	// m.lines field is accessed only for a small handful.
+	// So it would make sense to allocate it lazily.
+	lines *token.File
 }
 
 // NewColumnMapper creates a new column mapper for the given uri and content.
 func NewColumnMapper(uri span.URI, content []byte) *ColumnMapper {
-	tf := span.NewTokenFile(uri.Filename(), content)
+	fset := token.NewFileSet()
+	tf := fset.AddFile(uri.Filename(), -1, len(content))
+	tf.SetLinesForContent(content)
+
 	return &ColumnMapper{
 		URI:     uri,
-		TokFile: tf,
+		lines:   tf,
 		Content: content,
 	}
 }
@@ -105,7 +129,7 @@
 		return Range{}, bug.Errorf("column mapper is for file %q instead of %q", m.URI, s.URI())
 	}
 
-	s, err := s.WithOffset(m.TokFile)
+	s, err := s.WithOffset(m.lines)
 	if err != nil {
 		return Range{}, err
 	}
@@ -135,17 +159,20 @@
 	return Range{Start: startPosition, End: endPosition}, nil
 }
 
-// PosRange returns a protocol Range for the token.Pos interval Content[start:end].
-func (m *ColumnMapper) PosRange(start, end token.Pos) (Range, error) {
-	startOffset, err := safetoken.Offset(m.TokFile, start)
-	if err != nil {
-		return Range{}, fmt.Errorf("start: %v", err)
+// OffsetSpan converts a pair of byte offsets to a Span.
+func (m *ColumnMapper) OffsetSpan(start, end int) (span.Span, error) {
+	if start > end {
+		return span.Span{}, fmt.Errorf("start offset (%d) > end (%d)", start, end)
 	}
-	endOffset, err := safetoken.Offset(m.TokFile, end)
+	startPoint, err := m.OffsetPoint(start)
 	if err != nil {
-		return Range{}, fmt.Errorf("end: %v", err)
+		return span.Span{}, err
 	}
-	return m.OffsetRange(startOffset, endOffset)
+	endPoint, err := m.OffsetPoint(end)
+	if err != nil {
+		return span.Span{}, err
+	}
+	return span.New(m.URI, startPoint, endPoint), nil
 }
 
 // Position returns the protocol position for the specified point,
@@ -160,14 +187,14 @@
 // OffsetPosition returns the protocol position of the specified
 // offset within m.Content.
 func (m *ColumnMapper) OffsetPosition(offset int) (Position, error) {
-	// We use span.ToPosition for its "line+1 at EOF" workaround.
-	line, _, err := span.ToPosition(m.TokFile, offset)
+	// We use span.OffsetToLineCol8 for its "line+1 at EOF" workaround.
+	line, _, err := span.OffsetToLineCol8(m.lines, offset)
 	if err != nil {
 		return Position{}, fmt.Errorf("OffsetPosition: %v", err)
 	}
 	// If that workaround executed, skip the usual column computation.
 	char := 0
-	if offset != m.TokFile.Size() {
+	if offset != m.lines.Size() {
 		char = m.utf16Column(offset)
 	}
 	return Position{
@@ -224,24 +251,7 @@
 	if err != nil {
 		return span.Span{}, err
 	}
-	return span.New(m.URI, start, end).WithAll(m.TokFile)
-}
-
-func (m *ColumnMapper) RangeToSpanRange(r Range) (span.Range, error) {
-	spn, err := m.RangeSpan(r)
-	if err != nil {
-		return span.Range{}, err
-	}
-	return spn.Range(m.TokFile)
-}
-
-// Pos returns the token.Pos of protocol position p within the mapped file.
-func (m *ColumnMapper) Pos(p Position) (token.Pos, error) {
-	start, err := m.Point(p)
-	if err != nil {
-		return token.NoPos, err
-	}
-	return safetoken.Pos(m.TokFile, start.Offset())
+	return span.New(m.URI, start, end).WithAll(m.lines)
 }
 
 // Offset returns the utf-8 byte offset of p within the mapped file.
@@ -253,13 +263,23 @@
 	return start.Offset(), nil
 }
 
+// OffsetPoint returns the span.Point for the given byte offset.
+func (m *ColumnMapper) OffsetPoint(offset int) (span.Point, error) {
+	// We use span.ToPosition for its "line+1 at EOF" workaround.
+	line, col8, err := span.OffsetToLineCol8(m.lines, offset)
+	if err != nil {
+		return span.Point{}, fmt.Errorf("OffsetPoint: %v", err)
+	}
+	return span.NewPoint(line, col8, offset), nil
+}
+
 // Point returns a span.Point for the protocol position p within the mapped file.
 // The resulting point has a valid Position and Offset.
 func (m *ColumnMapper) Point(p Position) (span.Point, error) {
 	line := int(p.Line) + 1
 
 	// Find byte offset of start of containing line.
-	offset, err := span.ToOffset(m.TokFile, line, 1)
+	offset, err := span.ToOffset(m.lines, line, 1)
 	if err != nil {
 		return span.Point{}, err
 	}
diff --git a/gopls/internal/lsp/references.go b/gopls/internal/lsp/references.go
index 6f4e3ee..390e290 100644
--- a/gopls/internal/lsp/references.go
+++ b/gopls/internal/lsp/references.go
@@ -27,12 +27,12 @@
 	}
 	var locations []protocol.Location
 	for _, ref := range references {
-		refRange, err := ref.Range()
+		refRange, err := ref.MappedRange.Range()
 		if err != nil {
 			return nil, err
 		}
 		locations = append(locations, protocol.Location{
-			URI:   protocol.URIFromSpanURI(ref.URI()),
+			URI:   protocol.URIFromSpanURI(ref.MappedRange.URI()),
 			Range: refRange,
 		})
 	}
diff --git a/gopls/internal/lsp/safetoken/safetoken.go b/gopls/internal/lsp/safetoken/safetoken.go
index fa9c675..29cc1b1 100644
--- a/gopls/internal/lsp/safetoken/safetoken.go
+++ b/gopls/internal/lsp/safetoken/safetoken.go
@@ -41,6 +41,19 @@
 	return int(pos) - f.Base(), nil
 }
 
+// Offsets returns Offset(start) and Offset(end).
+func Offsets(f *token.File, start, end token.Pos) (int, int, error) {
+	startOffset, err := Offset(f, start)
+	if err != nil {
+		return 0, 0, fmt.Errorf("start: %v", err)
+	}
+	endOffset, err := Offset(f, end)
+	if err != nil {
+		return 0, 0, fmt.Errorf("end: %v", err)
+	}
+	return startOffset, endOffset, nil
+}
+
 // Pos returns f.Pos(offset), but first checks that the offset is
 // non-negative and not larger than the size of the file.
 func Pos(f *token.File, offset int) (token.Pos, error) {
diff --git a/gopls/internal/lsp/selection_range.go b/gopls/internal/lsp/selection_range.go
index 314f224..b7a0cdb 100644
--- a/gopls/internal/lsp/selection_range.go
+++ b/gopls/internal/lsp/selection_range.go
@@ -41,7 +41,7 @@
 
 	result := make([]protocol.SelectionRange, len(params.Positions))
 	for i, protocolPos := range params.Positions {
-		pos, err := pgf.Mapper.Pos(protocolPos)
+		pos, err := pgf.Pos(protocolPos)
 		if err != nil {
 			return nil, err
 		}
@@ -51,7 +51,7 @@
 		tail := &result[i] // tail of the Parent linked list, built head first
 
 		for j, node := range path {
-			rng, err := pgf.Mapper.PosRange(node.Pos(), node.End())
+			rng, err := pgf.PosRange(node.Pos(), node.End())
 			if err != nil {
 				return nil, err
 			}
diff --git a/gopls/internal/lsp/semantic.go b/gopls/internal/lsp/semantic.go
index 4117eb7..728f61d 100644
--- a/gopls/internal/lsp/semantic.go
+++ b/gopls/internal/lsp/semantic.go
@@ -182,8 +182,7 @@
 		return
 	}
 	// want a line and column from start (in LSP coordinates). Ignore line directives.
-	rng := source.NewMappedRange(e.pgf.Mapper, start, start+token.Pos(leng))
-	lspRange, err := rng.Range()
+	lspRange, err := e.pgf.PosRange(start, start+token.Pos(leng))
 	if err != nil {
 		event.Error(e.ctx, "failed to convert to range", err)
 		return
diff --git a/gopls/internal/lsp/source/call_hierarchy.go b/gopls/internal/lsp/source/call_hierarchy.go
index 076aed0..cce8a13 100644
--- a/gopls/internal/lsp/source/call_hierarchy.go
+++ b/gopls/internal/lsp/source/call_hierarchy.go
@@ -86,12 +86,12 @@
 	// once in the result but highlight all calls using FromRanges (ranges at which the calls occur)
 	var incomingCalls = map[protocol.Location]*protocol.CallHierarchyIncomingCall{}
 	for _, ref := range refs {
-		refRange, err := ref.Range()
+		refRange, err := ref.MappedRange.Range()
 		if err != nil {
 			return nil, err
 		}
 
-		callItem, err := enclosingNodeCallItem(snapshot, ref.pkg, ref.URI(), ref.ident.NamePos)
+		callItem, err := enclosingNodeCallItem(snapshot, ref.pkg, ref.MappedRange.URI(), ref.ident.NamePos)
 		if err != nil {
 			event.Error(ctx, "error getting enclosing node", err, tag.Method.Of(ref.Name))
 			continue
@@ -155,7 +155,7 @@
 		nameStart, nameEnd = funcLit.Type.Func, funcLit.Type.Params.Pos()
 		kind = protocol.Function
 	}
-	rng, err := NewMappedRange(pgf.Mapper, nameStart, nameEnd).Range()
+	rng, err := pgf.PosRange(nameStart, nameEnd)
 	if err != nil {
 		return protocol.CallHierarchyItem{}, err
 	}
@@ -199,7 +199,7 @@
 	if len(identifier.Declaration.MappedRange) == 0 {
 		return nil, nil
 	}
-	callExprs, err := collectCallExpressions(identifier.Declaration.MappedRange[0].m, node)
+	callExprs, err := collectCallExpressions(identifier.Declaration.MappedRange[0].File, node)
 	if err != nil {
 		return nil, err
 	}
@@ -208,7 +208,7 @@
 }
 
 // collectCallExpressions collects call expression ranges inside a function.
-func collectCallExpressions(mapper *protocol.ColumnMapper, node ast.Node) ([]protocol.Range, error) {
+func collectCallExpressions(pgf *ParsedGoFile, node ast.Node) ([]protocol.Range, error) {
 	type callPos struct {
 		start, end token.Pos
 	}
@@ -238,7 +238,7 @@
 
 	callRanges := []protocol.Range{}
 	for _, call := range callPositions {
-		callRange, err := NewMappedRange(mapper, call.start, call.end).Range()
+		callRange, err := pgf.PosRange(call.start, call.end)
 		if err != nil {
 			return nil, err
 		}
diff --git a/gopls/internal/lsp/source/code_lens.go b/gopls/internal/lsp/source/code_lens.go
index c87f416..f929256 100644
--- a/gopls/internal/lsp/source/code_lens.go
+++ b/gopls/internal/lsp/source/code_lens.go
@@ -67,7 +67,7 @@
 			return nil, err
 		}
 		// add a code lens to the top of the file which runs all benchmarks in the file
-		rng, err := NewMappedRange(pgf.Mapper, pgf.File.Package, pgf.File.Package).Range()
+		rng, err := pgf.PosRange(pgf.File.Package, pgf.File.Package)
 		if err != nil {
 			return nil, err
 		}
@@ -111,7 +111,7 @@
 			continue
 		}
 
-		rng, err := NewMappedRange(pgf.Mapper, fn.Pos(), fn.End()).Range()
+		rng, err := pgf.PosRange(fn.Pos(), fn.End())
 		if err != nil {
 			return out, err
 		}
@@ -177,7 +177,7 @@
 			if !strings.HasPrefix(l.Text, ggDirective) {
 				continue
 			}
-			rng, err := NewMappedRange(pgf.Mapper, l.Pos(), l.Pos()+token.Pos(len(ggDirective))).Range()
+			rng, err := pgf.PosRange(l.Pos(), l.Pos()+token.Pos(len(ggDirective)))
 			if err != nil {
 				return nil, err
 			}
@@ -214,7 +214,7 @@
 	if c == nil {
 		return nil, nil
 	}
-	rng, err := NewMappedRange(pgf.Mapper, c.Pos(), c.End()).Range()
+	rng, err := pgf.PosRange(c.Pos(), c.End())
 	if err != nil {
 		return nil, err
 	}
@@ -235,7 +235,7 @@
 		// Without a package name we have nowhere to put the codelens, so give up.
 		return nil, nil
 	}
-	rng, err := NewMappedRange(pgf.Mapper, pgf.File.Package, pgf.File.Package).Range()
+	rng, err := pgf.PosRange(pgf.File.Package, pgf.File.Package)
 	if err != nil {
 		return nil, err
 	}
diff --git a/gopls/internal/lsp/source/completion/completion.go b/gopls/internal/lsp/source/completion/completion.go
index 19d16a1..4d2da2e 100644
--- a/gopls/internal/lsp/source/completion/completion.go
+++ b/gopls/internal/lsp/source/completion/completion.go
@@ -291,6 +291,10 @@
 	content string
 	cursor  token.Pos // relative to rng.TokFile
 	rng     span.Range
+	// TODO(adonovan): keep the ColumnMapper (completer.mapper)
+	// nearby so we can convert rng to protocol form without
+	// needing to read the file again, as the sole caller of
+	// Selection.Range() must currently do.
 }
 
 func (p Selection) Content() string {
@@ -441,7 +445,7 @@
 		}
 		return items, surrounding, nil
 	}
-	pos, err := pgf.Mapper.Pos(protoPos)
+	pos, err := pgf.Pos(protoPos)
 	if err != nil {
 		return nil, nil, err
 	}
diff --git a/gopls/internal/lsp/source/completion/package.go b/gopls/internal/lsp/source/completion/package.go
index 70d98df..de2b75d 100644
--- a/gopls/internal/lsp/source/completion/package.go
+++ b/gopls/internal/lsp/source/completion/package.go
@@ -37,7 +37,7 @@
 		return nil, nil, err
 	}
 
-	pos, err := pgf.Mapper.Pos(position)
+	pos, err := pgf.Pos(position)
 	if err != nil {
 		return nil, nil, err
 	}
diff --git a/gopls/internal/lsp/source/completion/util.go b/gopls/internal/lsp/source/completion/util.go
index 72877a3..4b6ec09 100644
--- a/gopls/internal/lsp/source/completion/util.go
+++ b/gopls/internal/lsp/source/completion/util.go
@@ -312,13 +312,9 @@
 }
 
 func (c *completer) editText(from, to token.Pos, newText string) ([]protocol.TextEdit, error) {
-	start, err := safetoken.Offset(c.tokFile, from)
+	start, end, err := safetoken.Offsets(c.tokFile, from, to)
 	if err != nil {
-		return nil, err // can't happen: from came from c
-	}
-	end, err := safetoken.Offset(c.tokFile, to)
-	if err != nil {
-		return nil, err // can't happen: to came from c
+		return nil, err // can't happen: from/to came from c
 	}
 	return source.ToProtocolEdits(c.mapper, []diff.Edit{{
 		Start: start,
diff --git a/gopls/internal/lsp/source/extract.go b/gopls/internal/lsp/source/extract.go
index 0ac18e1..31a8598 100644
--- a/gopls/internal/lsp/source/extract.go
+++ b/gopls/internal/lsp/source/extract.go
@@ -134,11 +134,7 @@
 // line of code on which the insertion occurs.
 func calculateIndentation(content []byte, tok *token.File, insertBeforeStmt ast.Node) (string, error) {
 	line := tok.Line(insertBeforeStmt.Pos())
-	lineOffset, err := safetoken.Offset(tok, tok.LineStart(line))
-	if err != nil {
-		return "", err
-	}
-	stmtOffset, err := safetoken.Offset(tok, insertBeforeStmt.Pos())
+	lineOffset, stmtOffset, err := safetoken.Offsets(tok, tok.LineStart(line), insertBeforeStmt.Pos())
 	if err != nil {
 		return "", err
 	}
@@ -405,11 +401,7 @@
 
 	// We put the selection in a constructed file. We can then traverse and edit
 	// the extracted selection without modifying the original AST.
-	startOffset, err := safetoken.Offset(tok, rng.Start)
-	if err != nil {
-		return nil, err
-	}
-	endOffset, err := safetoken.Offset(tok, rng.End)
+	startOffset, endOffset, err := safetoken.Offsets(tok, rng.Start, rng.End)
 	if err != nil {
 		return nil, err
 	}
@@ -605,11 +597,7 @@
 
 	// We're going to replace the whole enclosing function,
 	// so preserve the text before and after the selected block.
-	outerStart, err := safetoken.Offset(tok, outer.Pos())
-	if err != nil {
-		return nil, err
-	}
-	outerEnd, err := safetoken.Offset(tok, outer.End())
+	outerStart, outerEnd, err := safetoken.Offsets(tok, outer.Pos(), outer.End())
 	if err != nil {
 		return nil, err
 	}
diff --git a/gopls/internal/lsp/source/fix.go b/gopls/internal/lsp/source/fix.go
index 34a6fe8..873db7f 100644
--- a/gopls/internal/lsp/source/fix.go
+++ b/gopls/internal/lsp/source/fix.go
@@ -15,6 +15,7 @@
 	"golang.org/x/tools/gopls/internal/lsp/analysis/fillstruct"
 	"golang.org/x/tools/gopls/internal/lsp/analysis/undeclaredname"
 	"golang.org/x/tools/gopls/internal/lsp/protocol"
+	"golang.org/x/tools/gopls/internal/lsp/safetoken"
 	"golang.org/x/tools/gopls/internal/span"
 	"golang.org/x/tools/internal/bug"
 )
@@ -93,6 +94,10 @@
 		if !end.IsValid() {
 			end = edit.Pos
 		}
+		startOffset, endOffset, err := safetoken.Offsets(tokFile, edit.Pos, end)
+		if err != nil {
+			return nil, err
+		}
 		fh, err := snapshot.GetVersionedFile(ctx, span.URIFromPath(tokFile.Name()))
 		if err != nil {
 			return nil, err
@@ -109,12 +114,13 @@
 			}
 			editsPerFile[fh.URI()] = te
 		}
+		// TODO(adonovan): once FileHandle has a ColumnMapper, eliminate this.
 		content, err := fh.Read()
 		if err != nil {
 			return nil, err
 		}
-		m := protocol.ColumnMapper{URI: fh.URI(), TokFile: tokFile, Content: content}
-		rng, err := m.PosRange(edit.Pos, end)
+		m := protocol.NewColumnMapper(fh.URI(), content)
+		rng, err := m.OffsetRange(startOffset, endOffset)
 		if err != nil {
 			return nil, err
 		}
@@ -137,7 +143,7 @@
 	if err != nil {
 		return nil, span.Range{}, nil, nil, nil, nil, fmt.Errorf("getting file for Identifier: %w", err)
 	}
-	rng, err := pgf.Mapper.RangeToSpanRange(pRng)
+	rng, err := pgf.RangeToSpanRange(pRng)
 	if err != nil {
 		return nil, span.Range{}, nil, nil, nil, nil, err
 	}
diff --git a/gopls/internal/lsp/source/folding_range.go b/gopls/internal/lsp/source/folding_range.go
index dacb5ae..01107fd 100644
--- a/gopls/internal/lsp/source/folding_range.go
+++ b/gopls/internal/lsp/source/folding_range.go
@@ -16,8 +16,8 @@
 
 // FoldingRangeInfo holds range and kind info of folding for an ast.Node
 type FoldingRangeInfo struct {
-	MappedRange
-	Kind protocol.FoldingRangeKind
+	MappedRange MappedRange
+	Kind        protocol.FoldingRangeKind
 }
 
 // FoldingRange gets all of the folding range for f.
@@ -42,10 +42,10 @@
 	}
 
 	// Get folding ranges for comments separately as they are not walked by ast.Inspect.
-	ranges = append(ranges, commentsFoldingRange(pgf.Mapper, pgf.File)...)
+	ranges = append(ranges, commentsFoldingRange(pgf)...)
 
 	visit := func(n ast.Node) bool {
-		rng := foldingRangeFunc(pgf.Tok, pgf.Mapper, n, lineFoldingOnly)
+		rng := foldingRangeFunc(pgf, n, lineFoldingOnly)
 		if rng != nil {
 			ranges = append(ranges, rng)
 		}
@@ -55,8 +55,8 @@
 	ast.Inspect(pgf.File, visit)
 
 	sort.Slice(ranges, func(i, j int) bool {
-		irng, _ := ranges[i].Range()
-		jrng, _ := ranges[j].Range()
+		irng, _ := ranges[i].MappedRange.Range()
+		jrng, _ := ranges[j].MappedRange.Range()
 		return protocol.CompareRange(irng, jrng) < 0
 	})
 
@@ -64,7 +64,7 @@
 }
 
 // foldingRangeFunc calculates the line folding range for ast.Node n
-func foldingRangeFunc(tokFile *token.File, m *protocol.ColumnMapper, n ast.Node, lineFoldingOnly bool) *FoldingRangeInfo {
+func foldingRangeFunc(pgf *ParsedGoFile, n ast.Node, lineFoldingOnly bool) *FoldingRangeInfo {
 	// TODO(suzmue): include trailing empty lines before the closing
 	// parenthesis/brace.
 	var kind protocol.FoldingRangeKind
@@ -76,7 +76,7 @@
 		if num := len(n.List); num != 0 {
 			startList, endList = n.List[0].Pos(), n.List[num-1].End()
 		}
-		start, end = validLineFoldingRange(tokFile, n.Lbrace, n.Rbrace, startList, endList, lineFoldingOnly)
+		start, end = validLineFoldingRange(pgf.Tok, n.Lbrace, n.Rbrace, startList, endList, lineFoldingOnly)
 	case *ast.CaseClause:
 		// Fold from position of ":" to end.
 		start, end = n.Colon+1, n.End()
@@ -92,7 +92,7 @@
 		if num := len(n.List); num != 0 {
 			startList, endList = n.List[0].Pos(), n.List[num-1].End()
 		}
-		start, end = validLineFoldingRange(tokFile, n.Opening, n.Closing, startList, endList, lineFoldingOnly)
+		start, end = validLineFoldingRange(pgf.Tok, n.Opening, n.Closing, startList, endList, lineFoldingOnly)
 	case *ast.GenDecl:
 		// If this is an import declaration, set the kind to be protocol.Imports.
 		if n.Tok == token.IMPORT {
@@ -103,7 +103,7 @@
 		if num := len(n.Specs); num != 0 {
 			startSpecs, endSpecs = n.Specs[0].Pos(), n.Specs[num-1].End()
 		}
-		start, end = validLineFoldingRange(tokFile, n.Lparen, n.Rparen, startSpecs, endSpecs, lineFoldingOnly)
+		start, end = validLineFoldingRange(pgf.Tok, n.Lparen, n.Rparen, startSpecs, endSpecs, lineFoldingOnly)
 	case *ast.BasicLit:
 		// Fold raw string literals from position of "`" to position of "`".
 		if n.Kind == token.STRING && len(n.Value) >= 2 && n.Value[0] == '`' && n.Value[len(n.Value)-1] == '`' {
@@ -115,7 +115,7 @@
 		if num := len(n.Elts); num != 0 {
 			startElts, endElts = n.Elts[0].Pos(), n.Elts[num-1].End()
 		}
-		start, end = validLineFoldingRange(tokFile, n.Lbrace, n.Rbrace, startElts, endElts, lineFoldingOnly)
+		start, end = validLineFoldingRange(pgf.Tok, n.Lbrace, n.Rbrace, startElts, endElts, lineFoldingOnly)
 	}
 
 	// Check that folding positions are valid.
@@ -123,11 +123,11 @@
 		return nil
 	}
 	// in line folding mode, do not fold if the start and end lines are the same.
-	if lineFoldingOnly && tokFile.Line(start) == tokFile.Line(end) {
+	if lineFoldingOnly && pgf.Tok.Line(start) == pgf.Tok.Line(end) {
 		return nil
 	}
 	return &FoldingRangeInfo{
-		MappedRange: NewMappedRange(m, start, end),
+		MappedRange: NewMappedRange(pgf, start, end),
 		Kind:        kind,
 	}
 }
@@ -157,9 +157,9 @@
 // commentsFoldingRange returns the folding ranges for all comment blocks in file.
 // The folding range starts at the end of the first line of the comment block, and ends at the end of the
 // comment block and has kind protocol.Comment.
-func commentsFoldingRange(m *protocol.ColumnMapper, file *ast.File) (comments []*FoldingRangeInfo) {
-	tokFile := m.TokFile
-	for _, commentGrp := range file.Comments {
+func commentsFoldingRange(pgf *ParsedGoFile) (comments []*FoldingRangeInfo) {
+	tokFile := pgf.Tok
+	for _, commentGrp := range pgf.File.Comments {
 		startGrpLine, endGrpLine := tokFile.Line(commentGrp.Pos()), tokFile.Line(commentGrp.End())
 		if startGrpLine == endGrpLine {
 			// Don't fold single line comments.
@@ -176,7 +176,7 @@
 		}
 		comments = append(comments, &FoldingRangeInfo{
 			// Fold from the end of the first line comment to the end of the comment block.
-			MappedRange: NewMappedRange(m, endLinePos, commentGrp.End()),
+			MappedRange: NewMappedRange(pgf, endLinePos, commentGrp.End()),
 			Kind:        protocol.Comment,
 		})
 	}
diff --git a/gopls/internal/lsp/source/format.go b/gopls/internal/lsp/source/format.go
index 6662137..a272218 100644
--- a/gopls/internal/lsp/source/format.go
+++ b/gopls/internal/lsp/source/format.go
@@ -199,7 +199,7 @@
 		fixedData = append(fixedData, '\n') // ApplyFixes may miss the newline, go figure.
 	}
 	edits := snapshot.View().Options().ComputeEdits(left, string(fixedData))
-	return protocolEditsFromSource([]byte(left), edits, pgf.Mapper.TokFile)
+	return protocolEditsFromSource([]byte(left), edits)
 }
 
 // importPrefix returns the prefix of the given file content through the final
@@ -314,7 +314,7 @@
 
 // protocolEditsFromSource converts text edits to LSP edits using the original
 // source.
-func protocolEditsFromSource(src []byte, edits []diff.Edit, tf *token.File) ([]protocol.TextEdit, error) {
+func protocolEditsFromSource(src []byte, edits []diff.Edit) ([]protocol.TextEdit, error) {
 	m := lsppos.NewMapper(src)
 	var result []protocol.TextEdit
 	for _, edit := range edits {
diff --git a/gopls/internal/lsp/source/highlight.go b/gopls/internal/lsp/source/highlight.go
index d073fff..9bd90e5 100644
--- a/gopls/internal/lsp/source/highlight.go
+++ b/gopls/internal/lsp/source/highlight.go
@@ -28,7 +28,7 @@
 		return nil, fmt.Errorf("getting package for Highlight: %w", err)
 	}
 
-	pos, err := pgf.Mapper.Pos(position)
+	pos, err := pgf.Pos(position)
 	if err != nil {
 		return nil, err
 	}
diff --git a/gopls/internal/lsp/source/hover.go b/gopls/internal/lsp/source/hover.go
index dd6ce40..2cf369b 100644
--- a/gopls/internal/lsp/source/hover.go
+++ b/gopls/internal/lsp/source/hover.go
@@ -83,7 +83,7 @@
 	if err != nil {
 		return nil, err
 	}
-	rng, err := ident.Range()
+	rng, err := ident.MappedRange.Range()
 	if err != nil {
 		return nil, err
 	}
@@ -104,11 +104,7 @@
 	ctx, done := event.Start(ctx, "source.hoverRune")
 	defer done()
 
-	r, mrng, err := findRune(ctx, snapshot, fh, position)
-	if err != nil {
-		return nil, err
-	}
-	rng, err := mrng.Range()
+	r, rng, err := findRune(ctx, snapshot, fh, position)
 	if err != nil {
 		return nil, err
 	}
@@ -138,18 +134,18 @@
 var ErrNoRuneFound = errors.New("no rune found")
 
 // findRune returns rune information for a position in a file.
-func findRune(ctx context.Context, snapshot Snapshot, fh FileHandle, position protocol.Position) (rune, MappedRange, error) {
+func findRune(ctx context.Context, snapshot Snapshot, fh FileHandle, position protocol.Position) (rune, protocol.Range, error) {
 	fh, err := snapshot.GetFile(ctx, fh.URI())
 	if err != nil {
-		return 0, MappedRange{}, err
+		return 0, protocol.Range{}, err
 	}
 	pgf, err := snapshot.ParseGo(ctx, fh, ParseFull)
 	if err != nil {
-		return 0, MappedRange{}, err
+		return 0, protocol.Range{}, err
 	}
-	pos, err := pgf.Mapper.Pos(position)
+	pos, err := pgf.Pos(position)
 	if err != nil {
-		return 0, MappedRange{}, err
+		return 0, protocol.Range{}, err
 	}
 
 	// Find the basic literal enclosing the given position, if there is one.
@@ -166,7 +162,7 @@
 		return lit == nil // descend unless target is found
 	})
 	if lit == nil {
-		return 0, MappedRange{}, ErrNoRuneFound
+		return 0, protocol.Range{}, ErrNoRuneFound
 	}
 
 	var r rune
@@ -177,26 +173,26 @@
 		if err != nil {
 			// If the conversion fails, it's because of an invalid syntax, therefore
 			// there is no rune to be found.
-			return 0, MappedRange{}, ErrNoRuneFound
+			return 0, protocol.Range{}, ErrNoRuneFound
 		}
 		r, _ = utf8.DecodeRuneInString(s)
 		if r == utf8.RuneError {
-			return 0, MappedRange{}, fmt.Errorf("rune error")
+			return 0, protocol.Range{}, fmt.Errorf("rune error")
 		}
 		start, end = lit.Pos(), lit.End()
 	case token.INT:
 		// It's an integer, scan only if it is a hex litteral whose bitsize in
 		// ranging from 8 to 32.
 		if !(strings.HasPrefix(lit.Value, "0x") && len(lit.Value[2:]) >= 2 && len(lit.Value[2:]) <= 8) {
-			return 0, MappedRange{}, ErrNoRuneFound
+			return 0, protocol.Range{}, ErrNoRuneFound
 		}
 		v, err := strconv.ParseUint(lit.Value[2:], 16, 32)
 		if err != nil {
-			return 0, MappedRange{}, err
+			return 0, protocol.Range{}, err
 		}
 		r = rune(v)
 		if r == utf8.RuneError {
-			return 0, MappedRange{}, fmt.Errorf("rune error")
+			return 0, protocol.Range{}, fmt.Errorf("rune error")
 		}
 		start, end = lit.Pos(), lit.End()
 	case token.STRING:
@@ -205,17 +201,17 @@
 		var found bool
 		litOffset, err := safetoken.Offset(pgf.Tok, lit.Pos())
 		if err != nil {
-			return 0, MappedRange{}, err
+			return 0, protocol.Range{}, err
 		}
 		offset, err := safetoken.Offset(pgf.Tok, pos)
 		if err != nil {
-			return 0, MappedRange{}, err
+			return 0, protocol.Range{}, err
 		}
 		for i := offset - litOffset; i > 0; i-- {
 			// Start at the cursor position and search backward for the beginning of a rune escape sequence.
 			rr, _ := utf8.DecodeRuneInString(lit.Value[i:])
 			if rr == utf8.RuneError {
-				return 0, MappedRange{}, fmt.Errorf("rune error")
+				return 0, protocol.Range{}, fmt.Errorf("rune error")
 			}
 			if rr == '\\' {
 				// Got the beginning, decode it.
@@ -223,7 +219,7 @@
 				r, _, tail, err = strconv.UnquoteChar(lit.Value[i:], '"')
 				if err != nil {
 					// If the conversion fails, it's because of an invalid syntax, therefore is no rune to be found.
-					return 0, MappedRange{}, ErrNoRuneFound
+					return 0, protocol.Range{}, ErrNoRuneFound
 				}
 				// Only the rune escape sequence part of the string has to be highlighted, recompute the range.
 				runeLen := len(lit.Value) - (int(i) + len(tail))
@@ -235,12 +231,16 @@
 		}
 		if !found {
 			// No escape sequence found
-			return 0, MappedRange{}, ErrNoRuneFound
+			return 0, protocol.Range{}, ErrNoRuneFound
 		}
 	default:
-		return 0, MappedRange{}, ErrNoRuneFound
+		return 0, protocol.Range{}, ErrNoRuneFound
 	}
-	return r, NewMappedRange(pgf.Mapper, start, end), nil
+	rng, err := pgf.PosRange(start, end)
+	if err != nil {
+		return 0, protocol.Range{}, err
+	}
+	return r, rng, nil
 }
 
 func HoverIdentifier(ctx context.Context, i *IdentifierInfo) (*HoverJSON, error) {
@@ -580,11 +580,7 @@
 			var spec ast.Spec
 			for _, s := range node.Specs {
 				// Avoid panics by guarding the calls to token.Offset (golang/go#48249).
-				start, err := safetoken.Offset(fullTok, s.Pos())
-				if err != nil {
-					return nil, err
-				}
-				end, err := safetoken.Offset(fullTok, s.End())
+				start, end, err := safetoken.Offsets(fullTok, s.Pos(), s.End())
 				if err != nil {
 					return nil, err
 				}
diff --git a/gopls/internal/lsp/source/identifier.go b/gopls/internal/lsp/source/identifier.go
index ad826da..bfd853f 100644
--- a/gopls/internal/lsp/source/identifier.go
+++ b/gopls/internal/lsp/source/identifier.go
@@ -24,13 +24,13 @@
 
 // IdentifierInfo holds information about an identifier in Go source.
 type IdentifierInfo struct {
-	Name     string
-	Snapshot Snapshot // only needed for .View(); TODO(adonovan): reduce.
-	MappedRange
+	Name        string
+	Snapshot    Snapshot // only needed for .View(); TODO(adonovan): reduce.
+	MappedRange MappedRange
 
 	Type struct {
-		MappedRange
-		Object types.Object
+		MappedRange MappedRange // TODO(adonovan): strength-reduce to a protocol.Location
+		Object      types.Object
 	}
 
 	Inferred *types.Signature
@@ -83,7 +83,7 @@
 	if err != nil {
 		return nil, err
 	}
-	pos, err := pgf.Mapper.Pos(position)
+	pos, err := pgf.Pos(position)
 	if err != nil {
 		return nil, err
 	}
@@ -114,24 +114,15 @@
 	// Special case for package declarations, since they have no
 	// corresponding types.Object.
 	if ident == file.Name {
-		rng, err := posToMappedRange(pkg, file.Name.Pos(), file.Name.End())
-		if err != nil {
-			return nil, err
-		}
-		var declAST *ast.File
+		rng := NewMappedRange(pgf, file.Name.Pos(), file.Name.End())
+		// If there's no package documentation, just use current file.
+		decl := pgf
 		for _, pgf := range pkg.CompiledGoFiles() {
 			if pgf.File.Doc != nil {
-				declAST = pgf.File
+				decl = pgf
 			}
 		}
-		// If there's no package documentation, just use current file.
-		if declAST == nil {
-			declAST = file
-		}
-		declRng, err := posToMappedRange(pkg, declAST.Name.Pos(), declAST.Name.End())
-		if err != nil {
-			return nil, err
-		}
+		declRng := NewMappedRange(decl, decl.File.Name.Pos(), decl.File.Name.End())
 		return &IdentifierInfo{
 			Name:        file.Name.Name,
 			ident:       file.Name,
@@ -140,7 +131,7 @@
 			qf:          qf,
 			Snapshot:    snapshot,
 			Declaration: Declaration{
-				node:        declAST.Name,
+				node:        decl.File.Name,
 				MappedRange: []MappedRange{declRng},
 			},
 		}, nil
@@ -199,7 +190,7 @@
 
 		// The builtin package isn't in the dependency graph, so the usual
 		// utilities won't work here.
-		rng := NewMappedRange(builtin.Mapper, decl.Pos(), decl.Pos()+token.Pos(len(result.Name)))
+		rng := NewMappedRange(builtin, decl.Pos(), decl.Pos()+token.Pos(len(result.Name)))
 		result.Declaration.MappedRange = append(result.Declaration.MappedRange, rng)
 		return result, nil
 	}
@@ -240,7 +231,7 @@
 			}
 			name := method.Names[0].Name
 			result.Declaration.node = method
-			rng := NewMappedRange(builtin.Mapper, method.Pos(), method.Pos()+token.Pos(len(name)))
+			rng := NewMappedRange(builtin, method.Pos(), method.Pos()+token.Pos(len(name)))
 			result.Declaration.MappedRange = append(result.Declaration.MappedRange, rng)
 			return result, nil
 		}
diff --git a/gopls/internal/lsp/source/inlay_hint.go b/gopls/internal/lsp/source/inlay_hint.go
index ade2f5f..3958e4b 100644
--- a/gopls/internal/lsp/source/inlay_hint.go
+++ b/gopls/internal/lsp/source/inlay_hint.go
@@ -111,7 +111,7 @@
 	start, end := pgf.File.Pos(), pgf.File.End()
 	if pRng.Start.Line < pRng.End.Line || pRng.Start.Character < pRng.End.Character {
 		// Adjust start and end for the specified range.
-		rng, err := pgf.Mapper.RangeToSpanRange(pRng)
+		rng, err := pgf.RangeToSpanRange(pRng)
 		if err != nil {
 			return nil, err
 		}
diff --git a/gopls/internal/lsp/source/references.go b/gopls/internal/lsp/source/references.go
index a1dcc54..c7529e8 100644
--- a/gopls/internal/lsp/source/references.go
+++ b/gopls/internal/lsp/source/references.go
@@ -23,8 +23,8 @@
 
 // ReferenceInfo holds information about reference to an identifier in Go source.
 type ReferenceInfo struct {
-	Name string
-	MappedRange
+	Name          string
+	MappedRange   MappedRange
 	ident         *ast.Ident
 	obj           types.Object
 	pkg           Package
@@ -74,7 +74,7 @@
 					if rdep.DepsByImpPath[UnquoteImportPath(imp)] == targetPkg.ID {
 						refs = append(refs, &ReferenceInfo{
 							Name:        pgf.File.Name.Name,
-							MappedRange: NewMappedRange(f.Mapper, imp.Pos(), imp.End()),
+							MappedRange: NewMappedRange(f, imp.Pos(), imp.End()),
 						})
 					}
 				}
@@ -93,7 +93,7 @@
 			}
 			refs = append(refs, &ReferenceInfo{
 				Name:        pgf.File.Name.Name,
-				MappedRange: NewMappedRange(f.Mapper, f.File.Name.Pos(), f.File.Name.End()),
+				MappedRange: NewMappedRange(f, f.File.Name.Pos(), f.File.Name.End()),
 			})
 		}
 
@@ -120,7 +120,7 @@
 	}
 	sort.Slice(toSort, func(i, j int) bool {
 		x, y := toSort[i], toSort[j]
-		if cmp := strings.Compare(string(x.URI()), string(y.URI())); cmp != 0 {
+		if cmp := strings.Compare(string(x.MappedRange.URI()), string(y.MappedRange.URI())); cmp != 0 {
 			return cmp < 0
 		}
 		return x.ident.Pos() < y.ident.Pos()
@@ -137,8 +137,8 @@
 		return nil, false, err
 	}
 	// Careful: because we used ParseHeader,
-	// Mapper.Pos(ppos) may be beyond EOF => (0, err).
-	pos, _ := pgf.Mapper.Pos(ppos)
+	// pgf.Pos(ppos) may be beyond EOF => (0, err).
+	pos, _ := pgf.Pos(ppos)
 	return pgf, pgf.File.Name.Pos() <= pos && pos <= pgf.File.Name.End(), nil
 }
 
@@ -261,11 +261,11 @@
 	if includeInterfaceRefs && !isType {
 		// TODO(adonovan): opt: don't go back into the position domain:
 		// we have complete type information already.
-		declRange, err := declIdent.Range()
+		declRange, err := declIdent.MappedRange.Range()
 		if err != nil {
 			return nil, err
 		}
-		fh, err := snapshot.GetFile(ctx, declIdent.URI())
+		fh, err := snapshot.GetFile(ctx, declIdent.MappedRange.URI())
 		if err != nil {
 			return nil, err
 		}
diff --git a/gopls/internal/lsp/source/rename.go b/gopls/internal/lsp/source/rename.go
index 37fb2d5..8cb50e8 100644
--- a/gopls/internal/lsp/source/rename.go
+++ b/gopls/internal/lsp/source/rename.go
@@ -107,7 +107,7 @@
 		}
 
 		// Return the location of the package declaration.
-		rng, err := pgf.Mapper.PosRange(pgf.File.Name.Pos(), pgf.File.Name.End())
+		rng, err := pgf.PosRange(pgf.File.Name.Pos(), pgf.File.Name.End())
 		if err != nil {
 			return nil, err, err
 		}
@@ -434,7 +434,7 @@
 		if f.File.Name == nil {
 			continue // no package declaration
 		}
-		rng, err := f.Mapper.PosRange(f.File.Name.Pos(), f.File.Name.End())
+		rng, err := f.PosRange(f.File.Name.Pos(), f.File.Name.End())
 		if err != nil {
 			return err
 		}
@@ -493,8 +493,7 @@
 				}
 
 				// Create text edit for the import path (string literal).
-				impPathMappedRange := NewMappedRange(f.Mapper, imp.Path.Pos(), imp.Path.End())
-				rng, err := impPathMappedRange.Range()
+				rng, err := f.PosRange(imp.Path.Pos(), imp.Path.End())
 				if err != nil {
 					return err
 				}
@@ -667,7 +666,7 @@
 		return nil, err
 	}
 	for _, ref := range r.refs {
-		refSpan, err := ref.Span()
+		refSpan, err := ref.MappedRange.Span()
 		if err != nil {
 			return nil, err
 		}
@@ -726,8 +725,7 @@
 				for _, locs := range docRegexp.FindAllIndex([]byte(line), -1) {
 					// The File.Offset static check complains
 					// even though these uses are manifestly safe.
-					start, _ := safetoken.Offset(tokFile, lineStart+token.Pos(locs[0]))
-					end, _ := safetoken.Offset(tokFile, lineStart+token.Pos(locs[1]))
+					start, end, _ := safetoken.Offsets(tokFile, lineStart+token.Pos(locs[0]), lineStart+token.Pos(locs[1]))
 					result[uri] = append(result[uri], diff.Edit{
 						Start: start,
 						End:   end,
@@ -813,15 +811,14 @@
 	// Replace the portion (possibly empty) of the spec before the path:
 	//     local "path"      or      "path"
 	//   ->      <-                -><-
-	rng := span.NewRange(tokFile, spec.Pos(), spec.Path.Pos())
-	spn, err := rng.Span()
+	start, end, err := safetoken.Offsets(tokFile, spec.Pos(), spec.Path.Pos())
 	if err != nil {
 		return nil, err
 	}
 
 	return &diff.Edit{
-		Start: spn.Start().Offset(),
-		End:   spn.End().Offset(),
+		Start: start,
+		End:   end,
 		New:   newText,
 	}, nil
 }
diff --git a/gopls/internal/lsp/source/signature_help.go b/gopls/internal/lsp/source/signature_help.go
index 3f12d90..a751b29 100644
--- a/gopls/internal/lsp/source/signature_help.go
+++ b/gopls/internal/lsp/source/signature_help.go
@@ -24,7 +24,7 @@
 	if err != nil {
 		return nil, 0, fmt.Errorf("getting file for SignatureHelp: %w", err)
 	}
-	pos, err := pgf.Mapper.Pos(position)
+	pos, err := pgf.Pos(position)
 	if err != nil {
 		return nil, 0, err
 	}
diff --git a/gopls/internal/lsp/source/source_test.go b/gopls/internal/lsp/source/source_test.go
index ed8d9a4..fccb91e 100644
--- a/gopls/internal/lsp/source/source_test.go
+++ b/gopls/internal/lsp/source/source_test.go
@@ -431,11 +431,11 @@
 }
 
 func conflict(t *testing.T, a, b *source.FoldingRangeInfo) bool {
-	arng, err := a.Range()
+	arng, err := a.MappedRange.Range()
 	if err != nil {
 		t.Fatal(err)
 	}
-	brng, err := b.Range()
+	brng, err := b.MappedRange.Range()
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -450,7 +450,7 @@
 	// to preserve the offsets.
 	for i := len(ranges) - 1; i >= 0; i-- {
 		fRange := ranges[i]
-		spn, err := fRange.Span()
+		spn, err := fRange.MappedRange.Span()
 		if err != nil {
 			return "", err
 		}
@@ -552,7 +552,7 @@
 		t.Fatal(err)
 	}
 	if d.IsType {
-		rng, err = ident.Type.Range()
+		rng, err = ident.Type.MappedRange.Range()
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -725,7 +725,7 @@
 			}
 			got := make(map[span.Span]bool)
 			for _, refInfo := range refs {
-				refSpan, err := refInfo.Span()
+				refSpan, err := refInfo.MappedRange.Span()
 				if err != nil {
 					t.Fatal(err)
 				}
diff --git a/gopls/internal/lsp/source/stub.go b/gopls/internal/lsp/source/stub.go
index 2568bd0..0d94d48 100644
--- a/gopls/internal/lsp/source/stub.go
+++ b/gopls/internal/lsp/source/stub.go
@@ -109,12 +109,11 @@
 
 	// Return the diff.
 	diffs := snapshot.View().Options().ComputeEdits(string(parsedConcreteFile.Src), source.String())
-	tf := parsedConcreteFile.Mapper.TokFile
 	var edits []analysis.TextEdit
 	for _, edit := range diffs {
 		edits = append(edits, analysis.TextEdit{
-			Pos:     tf.Pos(edit.Start),
-			End:     tf.Pos(edit.End),
+			Pos:     parsedConcreteFile.Tok.Pos(edit.Start),
+			End:     parsedConcreteFile.Tok.Pos(edit.End),
 			NewText: []byte(edit.New),
 		})
 	}
@@ -223,7 +222,7 @@
 	if err != nil {
 		return nil, 0, err
 	}
-	rng, err := spn.Range(pgf.Mapper.TokFile)
+	rng, err := spn.Range(pgf.Tok)
 	if err != nil {
 		return nil, 0, err
 	}
diff --git a/gopls/internal/lsp/source/util.go b/gopls/internal/lsp/source/util.go
index face4c9..0b7f3e4 100644
--- a/gopls/internal/lsp/source/util.go
+++ b/gopls/internal/lsp/source/util.go
@@ -20,66 +20,46 @@
 	"golang.org/x/tools/gopls/internal/lsp/protocol"
 	"golang.org/x/tools/gopls/internal/lsp/safetoken"
 	"golang.org/x/tools/gopls/internal/span"
-	"golang.org/x/tools/internal/bug"
 	"golang.org/x/tools/internal/typeparams"
 )
 
-// MappedRange provides mapped protocol.Range for a span.Range, accounting for
-// UTF-16 code points.
+// A MappedRange represents an interval within a parsed Go file and
+// has the ability to convert to protocol.Range or span.Span form.
 //
-// TOOD(adonovan): eliminate this type. Replace all uses by an
-// explicit pair (span.Range, protocol.ColumnMapper), and an operation
-// to map both to a protocol.Range.
+// TOOD(adonovan): eliminate this type by inlining it: make callers
+// hold the triple themselves, or convert to Mapper + start/end offsets
+// and hold that.
 type MappedRange struct {
-	spanRange span.Range             // the range in the compiled source (package.CompiledGoFiles)
-	m         *protocol.ColumnMapper // a mapper of the edited source (package.GoFiles)
+	// TODO(adonovan): eliminate sole tricky direct use of this,
+	// which is entangled with IdentifierInfo.Declaration.node.
+	File       *ParsedGoFile
+	start, end token.Pos
 }
 
 // NewMappedRange returns a MappedRange for the given file and
-// start/end positions, which must be valid within m.TokFile.
-func NewMappedRange(m *protocol.ColumnMapper, start, end token.Pos) MappedRange {
-	return MappedRange{
-		spanRange: span.NewRange(m.TokFile, start, end),
-		m:         m,
-	}
+// start/end positions, which must be valid within the file.
+func NewMappedRange(pgf *ParsedGoFile, start, end token.Pos) MappedRange {
+	_ = span.NewRange(pgf.Tok, start, end) // just for assertions
+	return MappedRange{File: pgf, start: start, end: end}
 }
 
 // Range returns the LSP range in the edited source.
-//
-// See the documentation of NewMappedRange for information on edited vs
-// compiled source.
 func (s MappedRange) Range() (protocol.Range, error) {
-	if s.m == nil {
-		return protocol.Range{}, bug.Errorf("invalid range")
-	}
-	spn, err := span.FileSpan(s.spanRange.TokFile, s.spanRange.Start, s.spanRange.End)
-	if err != nil {
-		return protocol.Range{}, err
-	}
-	return s.m.Range(spn)
+	return s.File.PosRange(s.start, s.end)
 }
 
-// Span returns the span corresponding to the mapped range in the edited
-// source.
-//
-// See the documentation of NewMappedRange for information on edited vs
-// compiled source.
+// Span returns the span corresponding to the mapped range in the edited source.
 func (s MappedRange) Span() (span.Span, error) {
-	// In the past, some code-paths have relied on Span returning an error if s
-	// is the zero value (i.e. s.m is nil). But this should be treated as a bug:
-	// observe that s.URI() would panic in this case.
-	if s.m == nil {
-		return span.Span{}, bug.Errorf("invalid range")
+	start, end, err := safetoken.Offsets(s.File.Tok, s.start, s.end)
+	if err != nil {
+		return span.Span{}, err
 	}
-	return span.FileSpan(s.spanRange.TokFile, s.spanRange.Start, s.spanRange.End)
+	return s.File.Mapper.OffsetSpan(start, end)
 }
 
 // URI returns the URI of the edited file.
-//
-// See the documentation of NewMappedRange for information on edited vs
-// compiled source.
 func (s MappedRange) URI() span.URI {
-	return s.m.URI
+	return s.File.Mapper.URI
 }
 
 func IsGenerated(ctx context.Context, snapshot Snapshot, uri span.URI) bool {
@@ -126,6 +106,10 @@
 
 // posToMappedRange returns the MappedRange for the given [start, end) span,
 // which must be among the transitive dependencies of pkg.
+//
+// TODO(adonovan): many of the callers need only the ParsedGoFile so
+// that they can call pgf.PosRange(pos, end) to get a Range; they
+// don't actually need a MappedRange.
 func posToMappedRange(pkg Package, pos, end token.Pos) (MappedRange, error) {
 	if !pos.IsValid() {
 		return MappedRange{}, fmt.Errorf("invalid start position")
@@ -139,7 +123,7 @@
 	if err != nil {
 		return MappedRange{}, err
 	}
-	return NewMappedRange(pgf.Mapper, pos, end), nil
+	return NewMappedRange(pgf, pos, end), nil
 }
 
 // FindPackageFromPos returns the Package for the given position, which must be
diff --git a/gopls/internal/lsp/source/view.go b/gopls/internal/lsp/source/view.go
index 0b73c74..21e9969 100644
--- a/gopls/internal/lsp/source/view.go
+++ b/gopls/internal/lsp/source/view.go
@@ -23,6 +23,7 @@
 	"golang.org/x/tools/go/packages"
 	"golang.org/x/tools/gopls/internal/govulncheck"
 	"golang.org/x/tools/gopls/internal/lsp/protocol"
+	"golang.org/x/tools/gopls/internal/lsp/safetoken"
 	"golang.org/x/tools/gopls/internal/span"
 	"golang.org/x/tools/internal/event/label"
 	"golang.org/x/tools/internal/event/tag"
@@ -380,6 +381,33 @@
 	ParseErr scanner.ErrorList
 }
 
+// Pos returns the token.Pos of protocol position p within the file.
+func (pgf *ParsedGoFile) Pos(p protocol.Position) (token.Pos, error) {
+	point, err := pgf.Mapper.Point(p)
+	if err != nil {
+		return token.NoPos, err
+	}
+	return safetoken.Pos(pgf.Tok, point.Offset())
+}
+
+// PosRange returns a protocol Range for the token.Pos interval in this file.
+func (pgf *ParsedGoFile) PosRange(start, end token.Pos) (protocol.Range, error) {
+	startOffset, endOffset, err := safetoken.Offsets(pgf.Tok, start, end)
+	if err != nil {
+		return protocol.Range{}, err
+	}
+	return pgf.Mapper.OffsetRange(startOffset, endOffset)
+}
+
+// RangeToSpanRange parses a protocol Range back into the go/token domain.
+func (pgf *ParsedGoFile) RangeToSpanRange(r protocol.Range) (span.Range, error) {
+	spn, err := pgf.Mapper.RangeSpan(r)
+	if err != nil {
+		return span.Range{}, err
+	}
+	return spn.Range(pgf.Tok)
+}
+
 // A ParsedModule contains the results of parsing a go.mod file.
 type ParsedModule struct {
 	URI         span.URI
diff --git a/gopls/internal/lsp/work/completion.go b/gopls/internal/lsp/work/completion.go
index 623d2ce..b3682e1 100644
--- a/gopls/internal/lsp/work/completion.go
+++ b/gopls/internal/lsp/work/completion.go
@@ -8,15 +8,14 @@
 	"context"
 	"errors"
 	"fmt"
-	"go/token"
 	"os"
 	"path/filepath"
 	"sort"
 	"strings"
 
-	"golang.org/x/tools/internal/event"
 	"golang.org/x/tools/gopls/internal/lsp/protocol"
 	"golang.org/x/tools/gopls/internal/lsp/source"
+	"golang.org/x/tools/internal/event"
 )
 
 func Completion(ctx context.Context, snapshot source.Snapshot, fh source.VersionedFileHandle, position protocol.Position) (*protocol.CompletionList, error) {
@@ -28,18 +27,17 @@
 	if err != nil {
 		return nil, fmt.Errorf("getting go.work file handle: %w", err)
 	}
-	pos, err := pw.Mapper.Pos(position)
+	cursor, err := pw.Mapper.Offset(position)
 	if err != nil {
-		return nil, fmt.Errorf("computing cursor position: %w", err)
+		return nil, fmt.Errorf("computing cursor offset: %w", err)
 	}
 
 	// Find the use statement the user is in.
-	cursor := pos - 1
 	use, pathStart, _ := usePath(pw, cursor)
 	if use == nil {
 		return &protocol.CompletionList{}, nil
 	}
-	completingFrom := use.Path[:cursor-token.Pos(pathStart)]
+	completingFrom := use.Path[:cursor-pathStart]
 
 	// We're going to find the completions of the user input
 	// (completingFrom) by doing a walk on the innermost directory
diff --git a/gopls/internal/lsp/work/hover.go b/gopls/internal/lsp/work/hover.go
index 641028b..a29d59c 100644
--- a/gopls/internal/lsp/work/hover.go
+++ b/gopls/internal/lsp/work/hover.go
@@ -8,7 +8,6 @@
 	"bytes"
 	"context"
 	"fmt"
-	"go/token"
 
 	"golang.org/x/mod/modfile"
 	"golang.org/x/tools/gopls/internal/lsp/protocol"
@@ -30,14 +29,14 @@
 	if err != nil {
 		return nil, fmt.Errorf("getting go.work file handle: %w", err)
 	}
-	pos, err := pw.Mapper.Pos(position)
+	offset, err := pw.Mapper.Offset(position)
 	if err != nil {
-		return nil, fmt.Errorf("computing cursor position: %w", err)
+		return nil, fmt.Errorf("computing cursor offset: %w", err)
 	}
 
 	// Confirm that the cursor is inside a use statement, and then find
 	// the position of the use statement's directory path.
-	use, pathStart, pathEnd := usePath(pw, pos)
+	use, pathStart, pathEnd := usePath(pw, offset)
 
 	// The cursor position is not on a use statement.
 	if use == nil {
@@ -70,7 +69,7 @@
 	}, nil
 }
 
-func usePath(pw *source.ParsedWorkFile, pos token.Pos) (use *modfile.Use, pathStart, pathEnd int) {
+func usePath(pw *source.ParsedWorkFile, offset int) (use *modfile.Use, pathStart, pathEnd int) {
 	for _, u := range pw.File.Use {
 		path := []byte(u.Path)
 		s, e := u.Syntax.Start.Byte, u.Syntax.End.Byte
@@ -82,7 +81,7 @@
 		// Shift the start position to the location of the
 		// module directory within the use statement.
 		pathStart, pathEnd = s+i, s+i+len(path)
-		if token.Pos(pathStart) <= pos && pos <= token.Pos(pathEnd) {
+		if pathStart <= offset && offset <= pathEnd {
 			return u, pathStart, pathEnd
 		}
 	}
diff --git a/gopls/internal/regtest/misc/failures_test.go b/gopls/internal/regtest/misc/failures_test.go
index b016966..f996514 100644
--- a/gopls/internal/regtest/misc/failures_test.go
+++ b/gopls/internal/regtest/misc/failures_test.go
@@ -50,7 +50,7 @@
 func TestFailingDiagnosticClearingOnEdit(t *testing.T) {
 	t.Skip("line directives //line ")
 	// badPackageDup contains a duplicate definition of the 'a' const.
-	// This is a minor variant of TestDiagnosticClearingOnEditfrom from
+	// This is a minor variant of TestDiagnosticClearingOnEdit from
 	// diagnostics_test.go, with a line directive, which makes no difference.
 	const badPackageDup = `
 -- go.mod --
diff --git a/gopls/internal/span/span.go b/gopls/internal/span/span.go
index 0c24a2d..36629f0 100644
--- a/gopls/internal/span/span.go
+++ b/gopls/internal/span/span.go
@@ -36,9 +36,9 @@
 }
 
 type point struct {
-	Line   int `json:"line"`
-	Column int `json:"column"`
-	Offset int `json:"offset"`
+	Line   int `json:"line"`   // 1-based line number
+	Column int `json:"column"` // 1-based, UTF-8 codes (bytes)
+	Offset int `json:"offset"` // 0-based byte offset
 }
 
 // Invalid is a span that reports false from IsValid
@@ -274,12 +274,12 @@
 }
 
 func (p *point) updatePosition(tf *token.File) error {
-	line, col, err := ToPosition(tf, p.Offset)
+	line, col8, err := OffsetToLineCol8(tf, p.Offset)
 	if err != nil {
 		return err
 	}
 	p.Line = line
-	p.Column = col
+	p.Column = col8
 	return nil
 }
 
diff --git a/gopls/internal/span/token.go b/gopls/internal/span/token.go
index ca78d67..2e71cba 100644
--- a/gopls/internal/span/token.go
+++ b/gopls/internal/span/token.go
@@ -15,6 +15,8 @@
 // Range represents a source code range in token.Pos form.
 // It also carries the token.File that produced the positions, so that it is
 // self contained.
+//
+// TODO(adonovan): move to safetoken.Range (but the Range.Span function must stay behind).
 type Range struct {
 	TokFile    *token.File // non-nil
 	Start, End token.Pos   // both IsValid()
@@ -55,14 +57,6 @@
 	}
 }
 
-// NewTokenFile returns a token.File for the given file content.
-func NewTokenFile(filename string, content []byte) *token.File {
-	fset := token.NewFileSet()
-	f := fset.AddFile(filename, -1, len(content))
-	f.SetLinesForContent(content)
-	return f
-}
-
 // IsPoint returns true if the range represents a single point.
 func (r Range) IsPoint() bool {
 	return r.Start == r.End
@@ -95,8 +89,6 @@
 		if err != nil {
 			return Span{}, err
 		}
-		// In the presence of line directives, a single File can have sections from
-		// multiple file names.
 		if endFilename != startFilename {
 			return Span{}, fmt.Errorf("span begins in file %q but ends in %q", startFilename, endFilename)
 		}
@@ -160,11 +152,13 @@
 	}, nil
 }
 
-// ToPosition converts a byte offset in the file corresponding to tf into
+// OffsetToLineCol8 converts a byte offset in the file corresponding to tf into
 // 1-based line and utf-8 column indexes.
-func ToPosition(tf *token.File, offset int) (int, int, error) {
-	_, line, col, err := positionFromOffset(tf, offset)
-	return line, col, err
+//
+// TODO(adonovan): move to safetoken package for consistency?
+func OffsetToLineCol8(tf *token.File, offset int) (int, int, error) {
+	_, line, col8, err := positionFromOffset(tf, offset)
+	return line, col8, err
 }
 
 // ToOffset converts a 1-based line and utf-8 column index into a byte offset