diff --git a/internal/lsp/cache/analysis.go b/internal/lsp/cache/analysis.go
index faf030655c..baaad5af67 100644
--- a/internal/lsp/cache/analysis.go
+++ b/internal/lsp/cache/analysis.go
@@ -30,7 +30,7 @@ func (s *snapshot) Analyze(ctx context.Context, id string, analyzers []*source.A
 		if !a.IsEnabled(s.view) {
 			continue
 		}
-		ah, err := s.actionHandle(ctx, packageID(id), a.Analyzer)
+		ah, err := s.actionHandle(ctx, PackageID(id), a.Analyzer)
 		if err != nil {
 			return nil, err
 		}
@@ -84,7 +84,7 @@ type packageFactKey struct {
 	typ reflect.Type
 }
 
-func (s *snapshot) actionHandle(ctx context.Context, id packageID, a *analysis.Analyzer) (*actionHandle, error) {
+func (s *snapshot) actionHandle(ctx context.Context, id PackageID, a *analysis.Analyzer) (*actionHandle, error) {
 	ph, err := s.buildPackageHandle(ctx, id, source.ParseFull)
 	if err != nil {
 		return nil, err
@@ -121,13 +121,13 @@ func (s *snapshot) actionHandle(ctx context.Context, id packageID, a *analysis.A
 		// An analysis that consumes/produces facts
 		// must run on the package's dependencies too.
 		if len(a.FactTypes) > 0 {
-			importIDs := make([]string, 0, len(ph.m.deps))
-			for _, importID := range ph.m.deps {
+			importIDs := make([]string, 0, len(ph.m.Deps))
+			for _, importID := range ph.m.Deps {
 				importIDs = append(importIDs, string(importID))
 			}
 			sort.Strings(importIDs) // for determinism
 			for _, importID := range importIDs {
-				depActionHandle, err := s.actionHandle(ctx, packageID(importID), a)
+				depActionHandle, err := s.actionHandle(ctx, PackageID(importID), a)
 				if err != nil {
 					return nil, err
 				}
diff --git a/internal/lsp/cache/cache.go b/internal/lsp/cache/cache.go
index 7221874a50..be03e638e0 100644
--- a/internal/lsp/cache/cache.go
+++ b/internal/lsp/cache/cache.go
@@ -198,7 +198,7 @@ func (c *Cache) ID() string                     { return c.id }
 func (c *Cache) MemStats() map[reflect.Type]int { return c.store.Stats() }
 
 type packageStat struct {
-	id        packageID
+	id        PackageID
 	mode      source.ParseMode
 	file      int64
 	ast       int64
@@ -224,7 +224,7 @@ func (c *Cache) PackageStats(withNames bool) template.HTML {
 				typInfoCost = typesInfoCost(v.pkg.typesInfo)
 			}
 			stat := packageStat{
-				id:        v.pkg.m.id,
+				id:        v.pkg.m.ID,
 				mode:      v.pkg.mode,
 				types:     typsCost,
 				typesInfo: typInfoCost,
diff --git a/internal/lsp/cache/check.go b/internal/lsp/cache/check.go
index 287451f002..2eb2d1e611 100644
--- a/internal/lsp/cache/check.go
+++ b/internal/lsp/cache/check.go
@@ -42,7 +42,7 @@ type packageHandle struct {
 	mode source.ParseMode
 
 	// m is the metadata associated with the package.
-	m *knownMetadata
+	m *KnownMetadata
 
 	// key is the hashed key for the package.
 	key packageHandleKey
@@ -50,7 +50,7 @@ type packageHandle struct {
 
 func (ph *packageHandle) packageKey() packageKey {
 	return packageKey{
-		id:   ph.m.id,
+		id:   ph.m.ID,
 		mode: ph.mode,
 	}
 }
@@ -85,7 +85,7 @@ type packageData struct {
 // It assumes that the given ID already has metadata available, so it does not
 // attempt to reload missing or invalid metadata. The caller must reload
 // metadata if needed.
-func (s *snapshot) buildPackageHandle(ctx context.Context, id packageID, mode source.ParseMode) (*packageHandle, error) {
+func (s *snapshot) buildPackageHandle(ctx context.Context, id PackageID, mode source.ParseMode) (*packageHandle, error) {
 	if ph := s.getPackage(id, mode); ph != nil {
 		return ph, nil
 	}
@@ -121,7 +121,7 @@ func (s *snapshot) buildPackageHandle(ctx context.Context, id packageID, mode so
 		}
 
 		data := &packageData{}
-		data.pkg, data.err = typeCheck(ctx, snapshot, m.metadata, mode, deps)
+		data.pkg, data.err = typeCheck(ctx, snapshot, m.Metadata, mode, deps)
 		// Make sure that the workers above have finished before we return,
 		// especially in case of cancellation.
 		wg.Wait()
@@ -140,16 +140,16 @@ func (s *snapshot) buildPackageHandle(ctx context.Context, id packageID, mode so
 }
 
 // buildKey computes the key for a given packageHandle.
-func (s *snapshot) buildKey(ctx context.Context, id packageID, mode source.ParseMode) (*packageHandle, map[packagePath]*packageHandle, error) {
+func (s *snapshot) buildKey(ctx context.Context, id PackageID, mode source.ParseMode) (*packageHandle, map[PackagePath]*packageHandle, error) {
 	m := s.getMetadata(id)
 	if m == nil {
 		return nil, nil, errors.Errorf("no metadata for %s", id)
 	}
-	goFiles, err := s.parseGoHandles(ctx, m.goFiles, mode)
+	goFiles, err := s.parseGoHandles(ctx, m.GoFiles, mode)
 	if err != nil {
 		return nil, nil, err
 	}
-	compiledGoFiles, err := s.parseGoHandles(ctx, m.compiledGoFiles, mode)
+	compiledGoFiles, err := s.parseGoHandles(ctx, m.CompiledGoFiles, mode)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -160,12 +160,12 @@ func (s *snapshot) buildKey(ctx context.Context, id packageID, mode source.Parse
 		mode:            mode,
 	}
 	// Make sure all of the depList are sorted.
-	depList := append([]packageID{}, m.deps...)
+	depList := append([]PackageID{}, m.Deps...)
 	sort.Slice(depList, func(i, j int) bool {
 		return depList[i] < depList[j]
 	})
 
-	deps := make(map[packagePath]*packageHandle)
+	deps := make(map[PackagePath]*packageHandle)
 
 	// Begin computing the key by getting the depKeys for all dependencies.
 	var depKeys []packageHandleKey
@@ -174,7 +174,7 @@ func (s *snapshot) buildKey(ctx context.Context, id packageID, mode source.Parse
 		// Don't use invalid metadata for dependencies if the top-level
 		// metadata is valid. We only load top-level packages, so if the
 		// top-level is valid, all of its dependencies should be as well.
-		if err != nil || m.valid && !depHandle.m.valid {
+		if err != nil || m.Valid && !depHandle.m.Valid {
 			if err != nil {
 				event.Error(ctx, fmt.Sprintf("%s: no dep handle for %s", id, depID), err, tag.Snapshot.Of(s.id))
 			} else {
@@ -189,15 +189,15 @@ func (s *snapshot) buildKey(ctx context.Context, id packageID, mode source.Parse
 			depKeys = append(depKeys, packageHandleKey(fmt.Sprintf("%s import not found", depID)))
 			continue
 		}
-		deps[depHandle.m.pkgPath] = depHandle
+		deps[depHandle.m.PkgPath] = depHandle
 		depKeys = append(depKeys, depHandle.key)
 	}
 	experimentalKey := s.View().Options().ExperimentalPackageCacheKey
-	ph.key = checkPackageKey(ph.m.id, compiledGoFiles, m.config, depKeys, mode, experimentalKey)
+	ph.key = checkPackageKey(ph.m.ID, compiledGoFiles, m.Config, depKeys, mode, experimentalKey)
 	return ph, deps, nil
 }
 
-func (s *snapshot) workspaceParseMode(id packageID) source.ParseMode {
+func (s *snapshot) workspaceParseMode(id PackageID) source.ParseMode {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	_, ws := s.workspacePackages[id]
@@ -213,7 +213,7 @@ func (s *snapshot) workspaceParseMode(id packageID) source.ParseMode {
 	return source.ParseExported
 }
 
-func checkPackageKey(id packageID, pghs []*parseGoHandle, cfg *packages.Config, deps []packageHandleKey, mode source.ParseMode, experimentalKey bool) packageHandleKey {
+func checkPackageKey(id PackageID, pghs []*parseGoHandle, cfg *packages.Config, deps []packageHandleKey, mode source.ParseMode, experimentalKey bool) packageHandleKey {
 	b := bytes.NewBuffer(nil)
 	b.WriteString(string(id))
 	if !experimentalKey {
@@ -277,17 +277,17 @@ func (ph *packageHandle) check(ctx context.Context, s *snapshot) (*pkg, error) {
 }
 
 func (ph *packageHandle) CompiledGoFiles() []span.URI {
-	return ph.m.compiledGoFiles
+	return ph.m.CompiledGoFiles
 }
 
 func (ph *packageHandle) ID() string {
-	return string(ph.m.id)
+	return string(ph.m.ID)
 }
 
 func (ph *packageHandle) cached(g *memoize.Generation) (*pkg, error) {
 	v := ph.handle.Cached(g)
 	if v == nil {
-		return nil, errors.Errorf("no cached type information for %s", ph.m.pkgPath)
+		return nil, errors.Errorf("no cached type information for %s", ph.m.PkgPath)
 	}
 	data := v.(*packageData)
 	return data.pkg, data.err
@@ -305,7 +305,7 @@ func (s *snapshot) parseGoHandles(ctx context.Context, files []span.URI, mode so
 	return pghs, nil
 }
 
-func typeCheck(ctx context.Context, snapshot *snapshot, m *metadata, mode source.ParseMode, deps map[packagePath]*packageHandle) (*pkg, error) {
+func typeCheck(ctx context.Context, snapshot *snapshot, m *Metadata, mode source.ParseMode, deps map[PackagePath]*packageHandle) (*pkg, error) {
 	var filter *unexportedFilter
 	if mode == source.ParseExported {
 		filter = &unexportedFilter{uses: map[string]bool{}}
@@ -321,7 +321,7 @@ func typeCheck(ctx context.Context, snapshot *snapshot, m *metadata, mode source
 		// time keeping those names.
 		missing, unexpected := filter.ProcessErrors(pkg.typeErrors)
 		if len(unexpected) == 0 && len(missing) != 0 {
-			event.Log(ctx, fmt.Sprintf("discovered missing identifiers: %v", missing), tag.Package.Of(string(m.id)))
+			event.Log(ctx, fmt.Sprintf("discovered missing identifiers: %v", missing), tag.Package.Of(string(m.ID)))
 			pkg, err = doTypeCheck(ctx, snapshot, m, mode, deps, filter)
 			if err != nil {
 				return nil, err
@@ -329,7 +329,7 @@ func typeCheck(ctx context.Context, snapshot *snapshot, m *metadata, mode source
 			missing, unexpected = filter.ProcessErrors(pkg.typeErrors)
 		}
 		if len(unexpected) != 0 || len(missing) != 0 {
-			event.Log(ctx, fmt.Sprintf("falling back to safe trimming due to type errors: %v or still-missing identifiers: %v", unexpected, missing), tag.Package.Of(string(m.id)))
+			event.Log(ctx, fmt.Sprintf("falling back to safe trimming due to type errors: %v or still-missing identifiers: %v", unexpected, missing), tag.Package.Of(string(m.ID)))
 			pkg, err = doTypeCheck(ctx, snapshot, m, mode, deps, nil)
 			if err != nil {
 				return nil, err
@@ -338,13 +338,13 @@ func typeCheck(ctx context.Context, snapshot *snapshot, m *metadata, mode source
 	}
 	// If this is a replaced module in the workspace, the version is
 	// meaningless, and we don't want clients to access it.
-	if m.module != nil {
-		version := m.module.Version
+	if m.Module != nil {
+		version := m.Module.Version
 		if source.IsWorkspaceModuleVersion(version) {
 			version = ""
 		}
 		pkg.version = &module.Version{
-			Path:    m.module.Path,
+			Path:    m.Module.Path,
 			Version: version,
 		}
 	}
@@ -354,7 +354,7 @@ func typeCheck(ctx context.Context, snapshot *snapshot, m *metadata, mode source
 		return pkg, nil
 	}
 
-	for _, e := range m.errors {
+	for _, e := range m.Errors {
 		diags, err := goPackagesErrorDiagnostics(snapshot, pkg, e)
 		if err != nil {
 			event.Error(ctx, "unable to compute positions for list errors", err, tag.Package.Of(pkg.ID()))
@@ -420,15 +420,15 @@ func typeCheck(ctx context.Context, snapshot *snapshot, m *metadata, mode source
 	return pkg, nil
 }
 
-func doTypeCheck(ctx context.Context, snapshot *snapshot, m *metadata, mode source.ParseMode, deps map[packagePath]*packageHandle, astFilter *unexportedFilter) (*pkg, error) {
-	ctx, done := event.Start(ctx, "cache.typeCheck", tag.Package.Of(string(m.id)))
+func doTypeCheck(ctx context.Context, snapshot *snapshot, m *Metadata, mode source.ParseMode, deps map[PackagePath]*packageHandle, astFilter *unexportedFilter) (*pkg, error) {
+	ctx, done := event.Start(ctx, "cache.typeCheck", tag.Package.Of(string(m.ID)))
 	defer done()
 
 	pkg := &pkg{
 		m:       m,
 		mode:    mode,
-		imports: make(map[packagePath]*pkg),
-		types:   types.NewPackage(string(m.pkgPath), string(m.name)),
+		imports: make(map[PackagePath]*pkg),
+		types:   types.NewPackage(string(m.PkgPath), string(m.Name)),
 		typesInfo: &types.Info{
 			Types:      make(map[ast.Expr]types.TypeAndValue),
 			Defs:       make(map[*ast.Ident]types.Object),
@@ -437,11 +437,11 @@ func doTypeCheck(ctx context.Context, snapshot *snapshot, m *metadata, mode sour
 			Selections: make(map[*ast.SelectorExpr]*types.Selection),
 			Scopes:     make(map[ast.Node]*types.Scope),
 		},
-		typesSizes: m.typesSizes,
+		typesSizes: m.TypesSizes,
 	}
 	typeparams.InitInferred(pkg.typesInfo)
 
-	for _, gf := range pkg.m.goFiles {
+	for _, gf := range pkg.m.GoFiles {
 		// In the presence of line directives, we may need to report errors in
 		// non-compiled Go files, so we need to register them on the package.
 		// However, we only need to really parse them in ParseFull mode, when
@@ -466,18 +466,18 @@ func doTypeCheck(ctx context.Context, snapshot *snapshot, m *metadata, mode sour
 	}
 
 	// Use the default type information for the unsafe package.
-	if m.pkgPath == "unsafe" {
+	if m.PkgPath == "unsafe" {
 		// Don't type check Unsafe: it's unnecessary, and doing so exposes a data
 		// race to Unsafe.completed.
 		pkg.types = types.Unsafe
 		return pkg, nil
 	}
 
-	if len(m.compiledGoFiles) == 0 {
+	if len(m.CompiledGoFiles) == 0 {
 		// No files most likely means go/packages failed. Try to attach error
 		// messages to the file as much as possible.
 		var found bool
-		for _, e := range m.errors {
+		for _, e := range m.Errors {
 			srcDiags, err := goPackagesErrorDiagnostics(snapshot, pkg, e)
 			if err != nil {
 				continue
@@ -488,7 +488,7 @@ func doTypeCheck(ctx context.Context, snapshot *snapshot, m *metadata, mode sour
 		if found {
 			return pkg, nil
 		}
-		return nil, errors.Errorf("no parsed files for package %s, expected: %v, errors: %v", pkg.m.pkgPath, pkg.compiledGoFiles, m.errors)
+		return nil, errors.Errorf("no parsed files for package %s, expected: %v, errors: %v", pkg.m.PkgPath, pkg.compiledGoFiles, m.Errors)
 	}
 
 	cfg := &types.Config{
@@ -504,14 +504,14 @@ func doTypeCheck(ctx context.Context, snapshot *snapshot, m *metadata, mode sour
 			if dep == nil {
 				return nil, snapshot.missingPkgError(ctx, pkgPath)
 			}
-			if !source.IsValidImport(string(m.pkgPath), string(dep.m.pkgPath)) {
+			if !source.IsValidImport(string(m.PkgPath), string(dep.m.PkgPath)) {
 				return nil, errors.Errorf("invalid use of internal package %s", pkgPath)
 			}
 			depPkg, err := dep.check(ctx, snapshot)
 			if err != nil {
 				return nil, err
 			}
-			pkg.imports[depPkg.m.pkgPath] = depPkg
+			pkg.imports[depPkg.m.PkgPath] = depPkg
 			return depPkg.types, nil
 		}),
 	}
@@ -544,7 +544,7 @@ func doTypeCheck(ctx context.Context, snapshot *snapshot, m *metadata, mode sour
 }
 
 func parseCompiledGoFiles(ctx context.Context, snapshot *snapshot, mode source.ParseMode, pkg *pkg, astFilter *unexportedFilter) error {
-	for _, cgf := range pkg.m.compiledGoFiles {
+	for _, cgf := range pkg.m.CompiledGoFiles {
 		fh, err := snapshot.GetFile(ctx, cgf)
 		if err != nil {
 			return err
@@ -605,7 +605,7 @@ func (s *snapshot) depsErrors(ctx context.Context, pkg *pkg) ([]*source.Diagnost
 		}
 
 		directImporter := depsError.ImportStack[directImporterIdx]
-		if s.isWorkspacePackage(packageID(directImporter)) {
+		if s.isWorkspacePackage(PackageID(directImporter)) {
 			continue
 		}
 		relevantErrors = append(relevantErrors, depsError)
@@ -640,7 +640,7 @@ func (s *snapshot) depsErrors(ctx context.Context, pkg *pkg) ([]*source.Diagnost
 	for _, depErr := range relevantErrors {
 		for i := len(depErr.ImportStack) - 1; i >= 0; i-- {
 			item := depErr.ImportStack[i]
-			if s.isWorkspacePackage(packageID(item)) {
+			if s.isWorkspacePackage(PackageID(item)) {
 				break
 			}
 
@@ -686,11 +686,11 @@ func (s *snapshot) depsErrors(ctx context.Context, pkg *pkg) ([]*source.Diagnost
 	for _, depErr := range relevantErrors {
 		for i := len(depErr.ImportStack) - 1; i >= 0; i-- {
 			item := depErr.ImportStack[i]
-			m := s.getMetadata(packageID(item))
-			if m == nil || m.module == nil {
+			m := s.getMetadata(PackageID(item))
+			if m == nil || m.Module == nil {
 				continue
 			}
-			modVer := module.Version{Path: m.module.Path, Version: m.module.Version}
+			modVer := module.Version{Path: m.Module.Path, Version: m.Module.Version}
 			reference := findModuleReference(pm.File, modVer)
 			if reference == nil {
 				continue
@@ -809,14 +809,14 @@ func expandErrors(errs []types.Error, supportsRelatedInformation bool) []extende
 // resolveImportPath resolves an import path in pkg to a package from deps.
 // It should produce the same results as resolveImportPath:
 // https://cs.opensource.google/go/go/+/master:src/cmd/go/internal/load/pkg.go;drc=641918ee09cb44d282a30ee8b66f99a0b63eaef9;l=990.
-func resolveImportPath(importPath string, pkg *pkg, deps map[packagePath]*packageHandle) *packageHandle {
-	if dep := deps[packagePath(importPath)]; dep != nil {
+func resolveImportPath(importPath string, pkg *pkg, deps map[PackagePath]*packageHandle) *packageHandle {
+	if dep := deps[PackagePath(importPath)]; dep != nil {
 		return dep
 	}
 	// We may be in GOPATH mode, in which case we need to check vendor dirs.
 	searchDir := path.Dir(pkg.PkgPath())
 	for {
-		vdir := packagePath(path.Join(searchDir, "vendor", importPath))
+		vdir := PackagePath(path.Join(searchDir, "vendor", importPath))
 		if vdep := deps[vdir]; vdep != nil {
 			return vdep
 		}
diff --git a/internal/lsp/cache/errors.go b/internal/lsp/cache/errors.go
index b866646b9e..3f58d67c0f 100644
--- a/internal/lsp/cache/errors.go
+++ b/internal/lsp/cache/errors.go
@@ -41,7 +41,7 @@ func goPackagesErrorDiagnostics(snapshot *snapshot, pkg *pkg, e packages.Error)
 
 	var spn span.Span
 	if e.Pos == "" {
-		spn = parseGoListError(e.Msg, pkg.m.config.Dir)
+		spn = parseGoListError(e.Msg, pkg.m.Config.Dir)
 		// We may not have been able to parse a valid span. Apply the errors to all files.
 		if _, err := spanToRange(pkg, spn); err != nil {
 			var diags []*source.Diagnostic
@@ -56,7 +56,7 @@ func goPackagesErrorDiagnostics(snapshot *snapshot, pkg *pkg, e packages.Error)
 			return diags, nil
 		}
 	} else {
-		spn = span.ParseInDir(e.Pos, pkg.m.config.Dir)
+		spn = span.ParseInDir(e.Pos, pkg.m.Config.Dir)
 	}
 
 	rng, err := spanToRange(pkg, spn)
diff --git a/internal/lsp/cache/load.go b/internal/lsp/cache/load.go
index 5c027e72df..2886c86349 100644
--- a/internal/lsp/cache/load.go
+++ b/internal/lsp/cache/load.go
@@ -8,7 +8,6 @@ import (
 	"context"
 	"crypto/sha256"
 	"fmt"
-	"go/types"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -28,40 +27,6 @@ import (
 	errors "golang.org/x/xerrors"
 )
 
-// metadata holds package metadata extracted from a call to packages.Load.
-type metadata struct {
-	id              packageID
-	pkgPath         packagePath
-	name            packageName
-	goFiles         []span.URI
-	compiledGoFiles []span.URI
-	forTest         packagePath
-	typesSizes      types.Sizes
-	errors          []packages.Error
-	deps            []packageID
-	missingDeps     map[packagePath]struct{}
-	module          *packages.Module
-	depsErrors      []*packagesinternal.PackageError
-
-	// config is the *packages.Config associated with the loaded package.
-	config *packages.Config
-
-	// isIntermediateTestVariant reports whether the given package is an
-	// intermediate test variant, e.g.
-	// "golang.org/x/tools/internal/lsp/cache [golang.org/x/tools/internal/lsp/source.test]".
-	isIntermediateTestVariant bool
-}
-
-// Name implements the source.Metadata interface.
-func (m *metadata) Name() string {
-	return string(m.name)
-}
-
-// PkgPath implements the source.Metadata interface.
-func (m *metadata) PkgPath() string {
-	return string(m.pkgPath)
-}
-
 // load calls packages.Load for the given scopes, updating package metadata,
 // import graph, and mapped files with the result.
 func (s *snapshot) load(ctx context.Context, allowNetwork bool, scopes ...interface{}) (err error) {
@@ -80,7 +45,7 @@ func (s *snapshot) load(ctx context.Context, allowNetwork bool, scopes ...interf
 			s.clearShouldLoad(scope)
 		}()
 		switch scope := scope.(type) {
-		case packagePath:
+		case PackagePath:
 			if source.IsCommandLineArguments(string(scope)) {
 				panic("attempted to load command-line-arguments")
 			}
@@ -205,12 +170,12 @@ func (s *snapshot) load(ctx context.Context, allowNetwork bool, scopes ...interf
 		}
 		// Set the metadata for this package.
 		s.mu.Lock()
-		m, err := s.setMetadataLocked(ctx, packagePath(pkg.PkgPath), pkg, cfg, query, map[packageID]struct{}{})
+		m, err := s.setMetadataLocked(ctx, PackagePath(pkg.PkgPath), pkg, cfg, query, map[PackageID]struct{}{})
 		s.mu.Unlock()
 		if err != nil {
 			return err
 		}
-		if _, err := s.buildPackageHandle(ctx, m.id, s.workspaceParseMode(m.id)); err != nil {
+		if _, err := s.buildPackageHandle(ctx, m.ID, s.workspaceParseMode(m.ID)); err != nil {
 			return err
 		}
 	}
@@ -403,25 +368,25 @@ func getWorkspaceDir(ctx context.Context, h *memoize.Handle, g *memoize.Generati
 // setMetadataLocked extracts metadata from pkg and records it in s. It
 // recurses through pkg.Imports to ensure that metadata exists for all
 // dependencies.
-func (s *snapshot) setMetadataLocked(ctx context.Context, pkgPath packagePath, pkg *packages.Package, cfg *packages.Config, query []string, seen map[packageID]struct{}) (*metadata, error) {
-	id := packageID(pkg.ID)
+func (s *snapshot) setMetadataLocked(ctx context.Context, pkgPath PackagePath, pkg *packages.Package, cfg *packages.Config, query []string, seen map[PackageID]struct{}) (*Metadata, error) {
+	id := PackageID(pkg.ID)
 	if source.IsCommandLineArguments(pkg.ID) {
 		suffix := ":" + strings.Join(query, ",")
-		id = packageID(string(id) + suffix)
-		pkgPath = packagePath(string(pkgPath) + suffix)
+		id = PackageID(string(id) + suffix)
+		pkgPath = PackagePath(string(pkgPath) + suffix)
 	}
 	if _, ok := seen[id]; ok {
 		return nil, errors.Errorf("import cycle detected: %q", id)
 	}
 	// Recreate the metadata rather than reusing it to avoid locking.
-	m := &metadata{
-		id:         id,
-		pkgPath:    pkgPath,
-		name:       packageName(pkg.Name),
-		forTest:    packagePath(packagesinternal.GetForTest(pkg)),
-		typesSizes: pkg.TypesSizes,
-		config:     cfg,
-		module:     pkg.Module,
+	m := &Metadata{
+		ID:         id,
+		PkgPath:    pkgPath,
+		Name:       PackageName(pkg.Name),
+		ForTest:    PackagePath(packagesinternal.GetForTest(pkg)),
+		TypesSizes: pkg.TypesSizes,
+		Config:     cfg,
+		Module:     pkg.Module,
 		depsErrors: packagesinternal.GetDepsErrors(pkg),
 	}
 
@@ -432,41 +397,41 @@ func (s *snapshot) setMetadataLocked(ctx context.Context, pkgPath packagePath, p
 		if strings.Contains(err.Msg, "expected '") {
 			continue
 		}
-		m.errors = append(m.errors, err)
+		m.Errors = append(m.Errors, err)
 	}
 
 	uris := map[span.URI]struct{}{}
 	for _, filename := range pkg.CompiledGoFiles {
 		uri := span.URIFromPath(filename)
-		m.compiledGoFiles = append(m.compiledGoFiles, uri)
+		m.CompiledGoFiles = append(m.CompiledGoFiles, uri)
 		uris[uri] = struct{}{}
 	}
 	for _, filename := range pkg.GoFiles {
 		uri := span.URIFromPath(filename)
-		m.goFiles = append(m.goFiles, uri)
+		m.GoFiles = append(m.GoFiles, uri)
 		uris[uri] = struct{}{}
 	}
 	s.updateIDForURIsLocked(id, uris)
 
 	// TODO(rstambler): is this still necessary?
-	copied := map[packageID]struct{}{
+	copied := map[PackageID]struct{}{
 		id: {},
 	}
 	for k, v := range seen {
 		copied[k] = v
 	}
 	for importPath, importPkg := range pkg.Imports {
-		importPkgPath := packagePath(importPath)
-		importID := packageID(importPkg.ID)
+		importPkgPath := PackagePath(importPath)
+		importID := PackageID(importPkg.ID)
 
-		m.deps = append(m.deps, importID)
+		m.Deps = append(m.Deps, importID)
 
 		// Don't remember any imports with significant errors.
 		if importPkgPath != "unsafe" && len(importPkg.CompiledGoFiles) == 0 {
-			if m.missingDeps == nil {
-				m.missingDeps = make(map[packagePath]struct{})
+			if m.MissingDeps == nil {
+				m.MissingDeps = make(map[PackagePath]struct{})
 			}
-			m.missingDeps[importPkgPath] = struct{}{}
+			m.MissingDeps[importPkgPath] = struct{}{}
 			continue
 		}
 		if s.noValidMetadataForIDLocked(importID) {
@@ -479,25 +444,25 @@ func (s *snapshot) setMetadataLocked(ctx context.Context, pkgPath packagePath, p
 	// Add the metadata to the cache.
 
 	// If we've already set the metadata for this snapshot, reuse it.
-	if original, ok := s.metadata[m.id]; ok && original.valid {
+	if original, ok := s.metadata[m.ID]; ok && original.Valid {
 		// Since we've just reloaded, clear out shouldLoad.
-		original.shouldLoad = false
-		m = original.metadata
+		original.ShouldLoad = false
+		m = original.Metadata
 	} else {
-		s.metadata[m.id] = &knownMetadata{
-			metadata: m,
-			valid:    true,
+		s.metadata[m.ID] = &KnownMetadata{
+			Metadata: m,
+			Valid:    true,
 		}
 		// Invalidate any packages we may have associated with this metadata.
 		for _, mode := range []source.ParseMode{source.ParseHeader, source.ParseExported, source.ParseFull} {
-			key := packageKey{mode, m.id}
+			key := packageKey{mode, m.ID}
 			delete(s.packages, key)
 		}
 	}
 
 	// Set the workspace packages. If any of the package's files belong to the
 	// view, then the package may be a workspace package.
-	for _, uri := range append(m.compiledGoFiles, m.goFiles...) {
+	for _, uri := range append(m.CompiledGoFiles, m.GoFiles...) {
 		if !s.view.contains(uri) {
 			continue
 		}
@@ -509,16 +474,16 @@ func (s *snapshot) setMetadataLocked(ctx context.Context, pkgPath packagePath, p
 		}
 
 		switch {
-		case m.forTest == "":
+		case m.ForTest == "":
 			// A normal package.
-			s.workspacePackages[m.id] = pkgPath
-		case m.forTest == m.pkgPath, m.forTest+"_test" == m.pkgPath:
+			s.workspacePackages[m.ID] = pkgPath
+		case m.ForTest == m.PkgPath, m.ForTest+"_test" == m.PkgPath:
 			// The test variant of some workspace package or its x_test.
 			// To load it, we need to load the non-test variant with -test.
-			s.workspacePackages[m.id] = m.forTest
+			s.workspacePackages[m.ID] = m.ForTest
 		default:
 			// A test variant of some intermediate package. We don't care about it.
-			m.isIntermediateTestVariant = true
+			m.IsIntermediateTestVariant = true
 		}
 	}
 	return m, nil
diff --git a/internal/lsp/cache/metadata.go b/internal/lsp/cache/metadata.go
new file mode 100644
index 0000000000..bef7bf8e70
--- /dev/null
+++ b/internal/lsp/cache/metadata.go
@@ -0,0 +1,69 @@
+// Copyright 2021 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 cache
+
+import (
+	"go/types"
+
+	"golang.org/x/tools/go/packages"
+	"golang.org/x/tools/internal/packagesinternal"
+	"golang.org/x/tools/internal/span"
+)
+
+// Declare explicit types for package paths, names, and IDs to ensure that we
+// never use an ID where a path belongs, and vice versa. If we confused these,
+// it would result in confusing errors because package IDs often look like
+// package paths.
+type (
+	PackageID   string
+	PackagePath string
+	PackageName string
+)
+
+// Metadata holds package Metadata extracted from a call to packages.Load.
+type Metadata struct {
+	ID              PackageID
+	PkgPath         PackagePath
+	Name            PackageName
+	GoFiles         []span.URI
+	CompiledGoFiles []span.URI
+	ForTest         PackagePath
+	TypesSizes      types.Sizes
+	Errors          []packages.Error
+	Deps            []PackageID
+	MissingDeps     map[PackagePath]struct{}
+	Module          *packages.Module
+	depsErrors      []*packagesinternal.PackageError
+
+	// Config is the *packages.Config associated with the loaded package.
+	Config *packages.Config
+
+	// IsIntermediateTestVariant reports whether the given package is an
+	// intermediate test variant, e.g.
+	// "golang.org/x/tools/internal/lsp/cache [golang.org/x/tools/internal/lsp/source.test]".
+	IsIntermediateTestVariant bool
+}
+
+// Name implements the source.Metadata interface.
+func (m *Metadata) PackageName() string {
+	return string(m.Name)
+}
+
+// PkgPath implements the source.Metadata interface.
+func (m *Metadata) PackagePath() string {
+	return string(m.PkgPath)
+}
+
+// KnownMetadata is a wrapper around metadata that tracks its validity.
+type KnownMetadata struct {
+	*Metadata
+
+	// Valid is true if the given metadata is Valid.
+	// Invalid metadata can still be used if a metadata reload fails.
+	Valid bool
+
+	// ShouldLoad is true if the given metadata should be reloaded.
+	ShouldLoad bool
+}
diff --git a/internal/lsp/cache/parse.go b/internal/lsp/cache/parse.go
index e2c72442f8..742f48f6a1 100644
--- a/internal/lsp/cache/parse.go
+++ b/internal/lsp/cache/parse.go
@@ -107,9 +107,9 @@ type astCacheKey struct {
 
 func (s *snapshot) astCacheData(ctx context.Context, spkg source.Package, pos token.Pos) (*astCacheData, error) {
 	pkg := spkg.(*pkg)
-	pkgHandle := s.getPackage(pkg.m.id, pkg.mode)
+	pkgHandle := s.getPackage(pkg.m.ID, pkg.mode)
 	if pkgHandle == nil {
-		return nil, fmt.Errorf("could not reconstruct package handle for %v", pkg.m.id)
+		return nil, fmt.Errorf("could not reconstruct package handle for %v", pkg.m.ID)
 	}
 	tok := s.FileSet().File(pos)
 	if tok == nil {
diff --git a/internal/lsp/cache/pkg.go b/internal/lsp/cache/pkg.go
index 5a87a149be..88ea88665d 100644
--- a/internal/lsp/cache/pkg.go
+++ b/internal/lsp/cache/pkg.go
@@ -17,12 +17,12 @@ import (
 
 // pkg contains the type information needed by the source package.
 type pkg struct {
-	m               *metadata
+	m               *Metadata
 	mode            source.ParseMode
 	goFiles         []*source.ParsedGoFile
 	compiledGoFiles []*source.ParsedGoFile
 	diagnostics     []*source.Diagnostic
-	imports         map[packagePath]*pkg
+	imports         map[PackagePath]*pkg
 	version         *module.Version
 	parseErrors     []scanner.ErrorList
 	typeErrors      []types.Error
@@ -32,16 +32,6 @@ type pkg struct {
 	hasFixedFiles   bool
 }
 
-// Declare explicit types for package paths, names, and IDs to ensure that we
-// never use an ID where a path belongs, and vice versa. If we confused these,
-// it would result in confusing errors because package IDs often look like
-// package paths.
-type (
-	packageID   string
-	packagePath string
-	packageName string
-)
-
 // Declare explicit types for files and directories to distinguish between the two.
 type (
 	fileURI         span.URI
@@ -50,15 +40,15 @@ type (
 )
 
 func (p *pkg) ID() string {
-	return string(p.m.id)
+	return string(p.m.ID)
 }
 
 func (p *pkg) Name() string {
-	return string(p.m.name)
+	return string(p.m.Name)
 }
 
 func (p *pkg) PkgPath() string {
-	return string(p.m.pkgPath)
+	return string(p.m.PkgPath)
 }
 
 func (p *pkg) ParseMode() source.ParseMode {
@@ -80,7 +70,7 @@ func (p *pkg) File(uri span.URI) (*source.ParsedGoFile, error) {
 			return gf, nil
 		}
 	}
-	return nil, errors.Errorf("no parsed file for %s in %v", uri, p.m.id)
+	return nil, errors.Errorf("no parsed file for %s in %v", uri, p.m.ID)
 }
 
 func (p *pkg) GetSyntax() []*ast.File {
@@ -108,11 +98,11 @@ func (p *pkg) IsIllTyped() bool {
 }
 
 func (p *pkg) ForTest() string {
-	return string(p.m.forTest)
+	return string(p.m.ForTest)
 }
 
 func (p *pkg) GetImport(pkgPath string) (source.Package, error) {
-	if imp := p.imports[packagePath(pkgPath)]; imp != nil {
+	if imp := p.imports[PackagePath(pkgPath)]; imp != nil {
 		return imp, nil
 	}
 	// Don't return a nil pointer because that still satisfies the interface.
@@ -124,14 +114,14 @@ func (p *pkg) MissingDependencies() []string {
 	// imports via the *types.Package. Only use metadata if p.types is nil.
 	if p.types == nil {
 		var md []string
-		for i := range p.m.missingDeps {
+		for i := range p.m.MissingDeps {
 			md = append(md, string(i))
 		}
 		return md
 	}
 	var md []string
 	for _, pkg := range p.types.Imports() {
-		if _, ok := p.m.missingDeps[packagePath(pkg.Path())]; ok {
+		if _, ok := p.m.MissingDeps[PackagePath(pkg.Path())]; ok {
 			md = append(md, pkg.Path())
 		}
 	}
@@ -151,7 +141,7 @@ func (p *pkg) Version() *module.Version {
 }
 
 func (p *pkg) HasListOrParseErrors() bool {
-	return len(p.m.errors) != 0 || len(p.parseErrors) != 0
+	return len(p.m.Errors) != 0 || len(p.parseErrors) != 0
 }
 
 func (p *pkg) HasTypeErrors() bool {
diff --git a/internal/lsp/cache/session.go b/internal/lsp/cache/session.go
index 487270b0d6..bcb799a668 100644
--- a/internal/lsp/cache/session.go
+++ b/internal/lsp/cache/session.go
@@ -230,14 +230,14 @@ func (s *Session) createView(ctx context.Context, name string, folder, tempWorks
 		initializeOnce:    &sync.Once{},
 		generation:        s.cache.store.Generation(generationName(v, 0)),
 		packages:          make(map[packageKey]*packageHandle),
-		ids:               make(map[span.URI][]packageID),
-		metadata:          make(map[packageID]*knownMetadata),
+		ids:               make(map[span.URI][]PackageID),
+		metadata:          make(map[PackageID]*KnownMetadata),
 		files:             make(map[span.URI]source.VersionedFileHandle),
 		goFiles:           make(map[parseKey]*parseGoHandle),
 		symbols:           make(map[span.URI]*symbolHandle),
-		importedBy:        make(map[packageID][]packageID),
+		importedBy:        make(map[PackageID][]PackageID),
 		actions:           make(map[actionKey]*actionHandle),
-		workspacePackages: make(map[packageID]packagePath),
+		workspacePackages: make(map[PackageID]PackagePath),
 		unloadableFiles:   make(map[span.URI]struct{}),
 		parseModHandles:   make(map[span.URI]*parseModHandle),
 		modTidyHandles:    make(map[span.URI]*modTidyHandle),
diff --git a/internal/lsp/cache/snapshot.go b/internal/lsp/cache/snapshot.go
index dc235d6995..d5f230a204 100644
--- a/internal/lsp/cache/snapshot.go
+++ b/internal/lsp/cache/snapshot.go
@@ -69,14 +69,14 @@ type snapshot struct {
 
 	// ids maps file URIs to package IDs.
 	// It may be invalidated on calls to go/packages.
-	ids map[span.URI][]packageID
+	ids map[span.URI][]PackageID
 
 	// metadata maps file IDs to their associated metadata.
 	// It may invalidated on calls to go/packages.
-	metadata map[packageID]*knownMetadata
+	metadata map[PackageID]*KnownMetadata
 
 	// importedBy maps package IDs to the list of packages that import them.
-	importedBy map[packageID][]packageID
+	importedBy map[PackageID][]PackageID
 
 	// files maps file URIs to their corresponding FileHandles.
 	// It may invalidated when a file's content changes.
@@ -97,7 +97,7 @@ type snapshot struct {
 
 	// workspacePackages contains the workspace's packages, which are loaded
 	// when the view is created.
-	workspacePackages map[packageID]packagePath
+	workspacePackages map[PackageID]PackagePath
 
 	// unloadableFiles keeps track of files that we've failed to load.
 	unloadableFiles map[span.URI]struct{}
@@ -126,7 +126,7 @@ type snapshot struct {
 
 type packageKey struct {
 	mode source.ParseMode
-	id   packageID
+	id   PackageID
 }
 
 type actionKey struct {
@@ -134,18 +134,6 @@ type actionKey struct {
 	analyzer *analysis.Analyzer
 }
 
-// knownMetadata is a wrapper around metadata that tracks its validity.
-type knownMetadata struct {
-	*metadata
-
-	// valid is true if the given metadata is valid.
-	// Invalid metadata can still be used if a metadata reload fails.
-	valid bool
-
-	// shouldLoad is true if the given metadata should be reloaded.
-	shouldLoad bool
-}
-
 func (s *snapshot) ID() uint64 {
 	return s.id
 }
@@ -535,7 +523,7 @@ func (s *snapshot) packageHandlesForFile(ctx context.Context, uri span.URI, mode
 	for _, id := range knownIDs {
 		// Filter out any intermediate test variants. We typically aren't
 		// interested in these packages for file= style queries.
-		if m := s.getMetadata(id); m != nil && m.isIntermediateTestVariant {
+		if m := s.getMetadata(id); m != nil && m.IsIntermediateTestVariant {
 			continue
 		}
 		var parseModes []source.ParseMode
@@ -563,7 +551,7 @@ func (s *snapshot) packageHandlesForFile(ctx context.Context, uri span.URI, mode
 	return phs, nil
 }
 
-func (s *snapshot) getOrLoadIDsForURI(ctx context.Context, uri span.URI) ([]packageID, error) {
+func (s *snapshot) getOrLoadIDsForURI(ctx context.Context, uri span.URI) ([]PackageID, error) {
 	knownIDs := s.getIDsForURI(uri)
 	reload := len(knownIDs) == 0
 	for _, id := range knownIDs {
@@ -605,11 +593,11 @@ func (s *snapshot) GetReverseDependencies(ctx context.Context, id string) ([]sou
 	if err := s.awaitLoaded(ctx); err != nil {
 		return nil, err
 	}
-	ids := make(map[packageID]struct{})
-	s.transitiveReverseDependencies(packageID(id), ids)
+	ids := make(map[PackageID]struct{})
+	s.transitiveReverseDependencies(PackageID(id), ids)
 
 	// Make sure to delete the original package ID from the map.
-	delete(ids, packageID(id))
+	delete(ids, PackageID(id))
 
 	var pkgs []source.Package
 	for id := range ids {
@@ -622,7 +610,7 @@ func (s *snapshot) GetReverseDependencies(ctx context.Context, id string) ([]sou
 	return pkgs, nil
 }
 
-func (s *snapshot) checkedPackage(ctx context.Context, id packageID, mode source.ParseMode) (*pkg, error) {
+func (s *snapshot) checkedPackage(ctx context.Context, id PackageID, mode source.ParseMode) (*pkg, error) {
 	ph, err := s.buildPackageHandle(ctx, id, mode)
 	if err != nil {
 		return nil, err
@@ -632,13 +620,13 @@ func (s *snapshot) checkedPackage(ctx context.Context, id packageID, mode source
 
 // transitiveReverseDependencies populates the ids map with package IDs
 // belonging to the provided package and its transitive reverse dependencies.
-func (s *snapshot) transitiveReverseDependencies(id packageID, ids map[packageID]struct{}) {
+func (s *snapshot) transitiveReverseDependencies(id PackageID, ids map[PackageID]struct{}) {
 	if _, ok := ids[id]; ok {
 		return
 	}
 	m := s.getMetadata(id)
 	// Only use invalid metadata if we support it.
-	if m == nil || !(m.valid || s.useInvalidMetadata()) {
+	if m == nil || !(m.Valid || s.useInvalidMetadata()) {
 		return
 	}
 	ids[id] = struct{}{}
@@ -682,13 +670,13 @@ func (s *snapshot) getModTidyHandle(uri span.URI) *modTidyHandle {
 	return s.modTidyHandles[uri]
 }
 
-func (s *snapshot) getImportedBy(id packageID) []packageID {
+func (s *snapshot) getImportedBy(id PackageID) []PackageID {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	return s.getImportedByLocked(id)
 }
 
-func (s *snapshot) getImportedByLocked(id packageID) []packageID {
+func (s *snapshot) getImportedByLocked(id PackageID) []PackageID {
 	// If we haven't rebuilt the import graph since creating the snapshot.
 	if len(s.importedBy) == 0 {
 		s.rebuildImportGraph()
@@ -701,13 +689,13 @@ func (s *snapshot) clearAndRebuildImportGraph() {
 	defer s.mu.Unlock()
 
 	// Completely invalidate the original map.
-	s.importedBy = make(map[packageID][]packageID)
+	s.importedBy = make(map[PackageID][]PackageID)
 	s.rebuildImportGraph()
 }
 
 func (s *snapshot) rebuildImportGraph() {
 	for id, m := range s.metadata {
-		for _, importID := range m.deps {
+		for _, importID := range m.Deps {
 			s.importedBy[importID] = append(s.importedBy[importID], id)
 		}
 	}
@@ -726,7 +714,7 @@ func (s *snapshot) addPackageHandle(ph *packageHandle) *packageHandle {
 	return ph
 }
 
-func (s *snapshot) workspacePackageIDs() (ids []packageID) {
+func (s *snapshot) workspacePackageIDs() (ids []PackageID) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
@@ -736,7 +724,7 @@ func (s *snapshot) workspacePackageIDs() (ids []packageID) {
 	return ids
 }
 
-func (s *snapshot) activePackageIDs() (ids []packageID) {
+func (s *snapshot) activePackageIDs() (ids []PackageID) {
 	if s.view.Options().MemoryMode == source.ModeNormal {
 		return s.workspacePackageIDs()
 	}
@@ -744,7 +732,7 @@ func (s *snapshot) activePackageIDs() (ids []packageID) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
-	seen := make(map[packageID]bool)
+	seen := make(map[PackageID]bool)
 	for id := range s.workspacePackages {
 		if s.isActiveLocked(id, seen) {
 			ids = append(ids, id)
@@ -753,9 +741,9 @@ func (s *snapshot) activePackageIDs() (ids []packageID) {
 	return ids
 }
 
-func (s *snapshot) isActiveLocked(id packageID, seen map[packageID]bool) (active bool) {
+func (s *snapshot) isActiveLocked(id PackageID, seen map[PackageID]bool) (active bool) {
 	if seen == nil {
-		seen = make(map[packageID]bool)
+		seen = make(map[PackageID]bool)
 	}
 	if seen, ok := seen[id]; ok {
 		return seen
@@ -767,12 +755,12 @@ func (s *snapshot) isActiveLocked(id packageID, seen map[packageID]bool) (active
 	if !ok {
 		return false
 	}
-	for _, cgf := range m.compiledGoFiles {
+	for _, cgf := range m.CompiledGoFiles {
 		if s.isOpenLocked(cgf) {
 			return true
 		}
 	}
-	for _, dep := range m.deps {
+	for _, dep := range m.Deps {
 		if s.isActiveLocked(dep, seen) {
 			return true
 		}
@@ -780,7 +768,7 @@ func (s *snapshot) isActiveLocked(id packageID, seen map[packageID]bool) (active
 	return false
 }
 
-func (s *snapshot) getWorkspacePkgPath(id packageID) packagePath {
+func (s *snapshot) getWorkspacePkgPath(id PackageID) PackagePath {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
@@ -1073,7 +1061,7 @@ func moduleForURI(modFiles map[span.URI]struct{}, uri span.URI) span.URI {
 	return match
 }
 
-func (s *snapshot) getPackage(id packageID, mode source.ParseMode) *packageHandle {
+func (s *snapshot) getPackage(id PackageID, mode source.ParseMode) *packageHandle {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
@@ -1104,7 +1092,8 @@ func (s *snapshot) addSymbolHandle(sh *symbolHandle) *symbolHandle {
 	s.symbols[uri] = sh
 	return sh
 }
-func (s *snapshot) getActionHandle(id packageID, m source.ParseMode, a *analysis.Analyzer) *actionHandle {
+
+func (s *snapshot) getActionHandle(id PackageID, m source.ParseMode, a *analysis.Analyzer) *actionHandle {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
@@ -1125,7 +1114,7 @@ func (s *snapshot) addActionHandle(ah *actionHandle) *actionHandle {
 	key := actionKey{
 		analyzer: ah.analyzer,
 		pkg: packageKey{
-			id:   ah.pkg.m.id,
+			id:   ah.pkg.m.ID,
 			mode: ah.pkg.mode,
 		},
 	}
@@ -1136,14 +1125,14 @@ func (s *snapshot) addActionHandle(ah *actionHandle) *actionHandle {
 	return ah
 }
 
-func (s *snapshot) getIDsForURI(uri span.URI) []packageID {
+func (s *snapshot) getIDsForURI(uri span.URI) []PackageID {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
 	return s.ids[uri]
 }
 
-func (s *snapshot) getMetadata(id packageID) *knownMetadata {
+func (s *snapshot) getMetadata(id PackageID) *KnownMetadata {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
@@ -1155,15 +1144,15 @@ func (s *snapshot) shouldLoad(scope interface{}) bool {
 	defer s.mu.Unlock()
 
 	switch scope := scope.(type) {
-	case packagePath:
-		var meta *knownMetadata
+	case PackagePath:
+		var meta *KnownMetadata
 		for _, m := range s.metadata {
-			if m.pkgPath != scope {
+			if m.PkgPath != scope {
 				continue
 			}
 			meta = m
 		}
-		if meta == nil || meta.shouldLoad {
+		if meta == nil || meta.ShouldLoad {
 			return true
 		}
 		return false
@@ -1175,7 +1164,7 @@ func (s *snapshot) shouldLoad(scope interface{}) bool {
 		}
 		for _, id := range ids {
 			m, ok := s.metadata[id]
-			if !ok || m.shouldLoad {
+			if !ok || m.ShouldLoad {
 				return true
 			}
 		}
@@ -1190,17 +1179,17 @@ func (s *snapshot) clearShouldLoad(scope interface{}) {
 	defer s.mu.Unlock()
 
 	switch scope := scope.(type) {
-	case packagePath:
-		var meta *knownMetadata
+	case PackagePath:
+		var meta *KnownMetadata
 		for _, m := range s.metadata {
-			if m.pkgPath == scope {
+			if m.PkgPath == scope {
 				meta = m
 			}
 		}
 		if meta == nil {
 			return
 		}
-		meta.shouldLoad = false
+		meta.ShouldLoad = false
 	case fileURI:
 		uri := span.URI(scope)
 		ids := s.ids[uri]
@@ -1209,7 +1198,7 @@ func (s *snapshot) clearShouldLoad(scope interface{}) {
 		}
 		for _, id := range ids {
 			if m, ok := s.metadata[id]; ok {
-				m.shouldLoad = false
+				m.ShouldLoad = false
 			}
 		}
 	}
@@ -1223,7 +1212,7 @@ func (s *snapshot) noValidMetadataForURILocked(uri span.URI) bool {
 		return true
 	}
 	for _, id := range ids {
-		if m, ok := s.metadata[id]; ok && m.valid {
+		if m, ok := s.metadata[id]; ok && m.Valid {
 			return false
 		}
 	}
@@ -1232,15 +1221,15 @@ func (s *snapshot) noValidMetadataForURILocked(uri span.URI) bool {
 
 // noValidMetadataForID reports whether there is no valid metadata for the
 // given ID.
-func (s *snapshot) noValidMetadataForID(id packageID) bool {
+func (s *snapshot) noValidMetadataForID(id PackageID) bool {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	return s.noValidMetadataForIDLocked(id)
 }
 
-func (s *snapshot) noValidMetadataForIDLocked(id packageID) bool {
+func (s *snapshot) noValidMetadataForIDLocked(id PackageID) bool {
 	m := s.metadata[id]
-	return m == nil || !m.valid
+	return m == nil || !m.Valid
 }
 
 // updateIDForURIsLocked adds the given ID to the set of known IDs for the given URI.
@@ -1248,10 +1237,10 @@ func (s *snapshot) noValidMetadataForIDLocked(id packageID) bool {
 // not "command-line-arguments" are preferred, so if a new ID comes in for a
 // URI that previously only had "command-line-arguments", the new ID will
 // replace the "command-line-arguments" ID.
-func (s *snapshot) updateIDForURIsLocked(id packageID, uris map[span.URI]struct{}) {
+func (s *snapshot) updateIDForURIsLocked(id PackageID, uris map[span.URI]struct{}) {
 	for uri := range uris {
 		// Collect the new set of IDs, preserving any valid existing IDs.
-		newIDs := []packageID{id}
+		newIDs := []PackageID{id}
 		for _, existingID := range s.ids[uri] {
 			// Don't set duplicates of the same ID.
 			if existingID == id {
@@ -1265,7 +1254,7 @@ func (s *snapshot) updateIDForURIsLocked(id packageID, uris map[span.URI]struct{
 			}
 			// If the metadata for an existing ID is invalid, and we are
 			// setting metadata for a new, valid ID--don't preserve the old ID.
-			if m, ok := s.metadata[existingID]; !ok || !m.valid {
+			if m, ok := s.metadata[existingID]; !ok || !m.Valid {
 				continue
 			}
 			newIDs = append(newIDs, existingID)
@@ -1277,7 +1266,7 @@ func (s *snapshot) updateIDForURIsLocked(id packageID, uris map[span.URI]struct{
 	}
 }
 
-func (s *snapshot) isWorkspacePackage(id packageID) bool {
+func (s *snapshot) isWorkspacePackage(id PackageID) bool {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
@@ -1363,7 +1352,7 @@ func (s *snapshot) awaitLoaded(ctx context.Context) error {
 		return nil
 	}
 	for _, m := range s.metadata {
-		if m.valid {
+		if m.Valid {
 			return nil
 		}
 	}
@@ -1487,9 +1476,9 @@ func (s *snapshot) reloadWorkspace(ctx context.Context) error {
 	// See which of the workspace packages are missing metadata.
 	s.mu.Lock()
 	missingMetadata := len(s.workspacePackages) == 0 || len(s.metadata) == 0
-	pkgPathSet := map[packagePath]struct{}{}
+	pkgPathSet := map[PackagePath]struct{}{}
 	for id, pkgPath := range s.workspacePackages {
-		if m, ok := s.metadata[id]; ok && m.valid {
+		if m, ok := s.metadata[id]; ok && m.Valid {
 			continue
 		}
 		missingMetadata = true
@@ -1634,7 +1623,7 @@ func checkSnapshotLocked(ctx context.Context, s *snapshot) {
 	// belonging to that workspace package.
 	for wsID := range s.workspacePackages {
 		if m, ok := s.metadata[wsID]; ok {
-			for _, uri := range m.goFiles {
+			for _, uri := range m.GoFiles {
 				found := false
 				for _, id := range s.ids[uri] {
 					if id == wsID {
@@ -1686,15 +1675,15 @@ func (s *snapshot) clone(ctx, bgCtx context.Context, changes map[span.URI]*fileC
 		builtin:           s.builtin,
 		initializeOnce:    s.initializeOnce,
 		initializedErr:    s.initializedErr,
-		ids:               make(map[span.URI][]packageID, len(s.ids)),
-		importedBy:        make(map[packageID][]packageID, len(s.importedBy)),
-		metadata:          make(map[packageID]*knownMetadata, len(s.metadata)),
+		ids:               make(map[span.URI][]PackageID, len(s.ids)),
+		importedBy:        make(map[PackageID][]PackageID, len(s.importedBy)),
+		metadata:          make(map[PackageID]*KnownMetadata, len(s.metadata)),
 		packages:          make(map[packageKey]*packageHandle, len(s.packages)),
 		actions:           make(map[actionKey]*actionHandle, len(s.actions)),
 		files:             make(map[span.URI]source.VersionedFileHandle, len(s.files)),
 		goFiles:           make(map[parseKey]*parseGoHandle, len(s.goFiles)),
 		symbols:           make(map[span.URI]*symbolHandle, len(s.symbols)),
-		workspacePackages: make(map[packageID]packagePath, len(s.workspacePackages)),
+		workspacePackages: make(map[PackageID]PackagePath, len(s.workspacePackages)),
 		unloadableFiles:   make(map[span.URI]struct{}, len(s.unloadableFiles)),
 		parseModHandles:   make(map[span.URI]*parseModHandle, len(s.parseModHandles)),
 		modTidyHandles:    make(map[span.URI]*modTidyHandle, len(s.modTidyHandles)),
@@ -1767,7 +1756,7 @@ func (s *snapshot) clone(ctx, bgCtx context.Context, changes map[span.URI]*fileC
 
 	// directIDs keeps track of package IDs that have directly changed.
 	// It maps id->invalidateMetadata.
-	directIDs := map[packageID]bool{}
+	directIDs := map[PackageID]bool{}
 
 	// Invalidate all package metadata if the workspace module has changed.
 	if workspaceReload {
@@ -1776,7 +1765,7 @@ func (s *snapshot) clone(ctx, bgCtx context.Context, changes map[span.URI]*fileC
 		}
 	}
 
-	changedPkgNames := map[packageID]struct{}{}
+	changedPkgNames := map[PackageID]struct{}{}
 	anyImportDeleted := false
 	for uri, change := range changes {
 		// Maybe reinitialize the view if we see a change in the vendor
@@ -1850,7 +1839,7 @@ func (s *snapshot) clone(ctx, bgCtx context.Context, changes map[span.URI]*fileC
 	// starting point to compare with.
 	if anyImportDeleted {
 		for id, metadata := range s.metadata {
-			if len(metadata.errors) > 0 {
+			if len(metadata.Errors) > 0 {
 				directIDs[id] = true
 			}
 		}
@@ -1861,9 +1850,9 @@ func (s *snapshot) clone(ctx, bgCtx context.Context, changes map[span.URI]*fileC
 	// idsToInvalidate keeps track of transitive reverse dependencies.
 	// If an ID is present in the map, invalidate its types.
 	// If an ID's value is true, invalidate its metadata too.
-	idsToInvalidate := map[packageID]bool{}
-	var addRevDeps func(packageID, bool)
-	addRevDeps = func(id packageID, invalidateMetadata bool) {
+	idsToInvalidate := map[PackageID]bool{}
+	var addRevDeps func(PackageID, bool)
+	addRevDeps = func(id PackageID, invalidateMetadata bool) {
 		current, seen := idsToInvalidate[id]
 		newInvalidateMetadata := current || invalidateMetadata
 
@@ -1903,7 +1892,7 @@ func (s *snapshot) clone(ctx, bgCtx context.Context, changes map[span.URI]*fileC
 	// If a file has been deleted, we must delete metadata all packages
 	// containing that file.
 	workspaceModeChanged := s.workspaceMode() != result.workspaceMode()
-	skipID := map[packageID]bool{}
+	skipID := map[PackageID]bool{}
 	for _, c := range changes {
 		if c.exists {
 			continue
@@ -1918,9 +1907,9 @@ func (s *snapshot) clone(ctx, bgCtx context.Context, changes map[span.URI]*fileC
 
 	// Collect all of the IDs that are reachable from the workspace packages.
 	// Any unreachable IDs will have their metadata deleted outright.
-	reachableID := map[packageID]bool{}
-	var addForwardDeps func(packageID)
-	addForwardDeps = func(id packageID) {
+	reachableID := map[PackageID]bool{}
+	var addForwardDeps func(PackageID)
+	addForwardDeps = func(id PackageID) {
 		if reachableID[id] {
 			return
 		}
@@ -1929,7 +1918,7 @@ func (s *snapshot) clone(ctx, bgCtx context.Context, changes map[span.URI]*fileC
 		if !ok {
 			return
 		}
-		for _, depID := range m.deps {
+		for _, depID := range m.Deps {
 			addForwardDeps(depID)
 		}
 	}
@@ -1940,7 +1929,7 @@ func (s *snapshot) clone(ctx, bgCtx context.Context, changes map[span.URI]*fileC
 	// Copy the URI to package ID mappings, skipping only those URIs whose
 	// metadata will be reloaded in future calls to load.
 	deleteInvalidMetadata := forceReloadMetadata || workspaceModeChanged
-	idsInSnapshot := map[packageID]bool{} // track all known IDs
+	idsInSnapshot := map[PackageID]bool{} // track all known IDs
 	for uri, ids := range s.ids {
 		for _, id := range ids {
 			invalidateMetadata := idsToInvalidate[id]
@@ -1967,10 +1956,10 @@ func (s *snapshot) clone(ctx, bgCtx context.Context, changes map[span.URI]*fileC
 		}
 		invalidateMetadata := idsToInvalidate[k]
 		// Mark invalidated metadata rather than deleting it outright.
-		result.metadata[k] = &knownMetadata{
-			metadata:   v.metadata,
-			valid:      v.valid && !invalidateMetadata,
-			shouldLoad: v.shouldLoad || invalidateMetadata,
+		result.metadata[k] = &KnownMetadata{
+			Metadata:   v.Metadata,
+			Valid:      v.Valid && !invalidateMetadata,
+			ShouldLoad: v.ShouldLoad || invalidateMetadata,
 		}
 	}
 
@@ -1990,11 +1979,11 @@ func (s *snapshot) clone(ctx, bgCtx context.Context, changes map[span.URI]*fileC
 		// the package is gone and we should no longer try to load it.
 		if m := s.metadata[id]; m != nil {
 			hasFiles := false
-			for _, uri := range s.metadata[id].goFiles {
+			for _, uri := range s.metadata[id].GoFiles {
 				// For internal tests, we need _test files, not just the normal
 				// ones. External tests only have _test files, but we can check
 				// them anyway.
-				if m.forTest != "" && !strings.HasSuffix(string(uri), "_test.go") {
+				if m.ForTest != "" && !strings.HasSuffix(string(uri), "_test.go") {
 					continue
 				}
 				if _, ok := result.files[uri]; ok {
@@ -2034,7 +2023,7 @@ func (s *snapshot) clone(ctx, bgCtx context.Context, changes map[span.URI]*fileC
 	// If the snapshot's workspace mode has changed, the packages loaded using
 	// the previous mode are no longer relevant, so clear them out.
 	if workspaceModeChanged {
-		result.workspacePackages = map[packageID]packagePath{}
+		result.workspacePackages = map[PackageID]PackagePath{}
 	}
 
 	// The snapshot may need to be reinitialized.
@@ -2050,7 +2039,7 @@ func (s *snapshot) clone(ctx, bgCtx context.Context, changes map[span.URI]*fileC
 // seen this URI before, we guess based on files in the same directory. This
 // is of course incorrect in build systems where packages are not organized by
 // directory.
-func guessPackageIDsForURI(uri span.URI, known map[span.URI][]packageID) []packageID {
+func guessPackageIDsForURI(uri span.URI, known map[span.URI][]PackageID) []PackageID {
 	packages := known[uri]
 	if len(packages) > 0 {
 		// We've seen this file before.
@@ -2083,7 +2072,7 @@ func guessPackageIDsForURI(uri span.URI, known map[span.URI][]packageID) []packa
 	}
 
 	// Aggregate all possibly relevant package IDs.
-	var found []packageID
+	var found []PackageID
 	for knownURI, ids := range known {
 		knownDir := filepath.Dir(knownURI.Filename())
 		knownFI, err := getInfo(knownDir)
diff --git a/internal/lsp/cache/view.go b/internal/lsp/cache/view.go
index 1989a62d5f..b54210ef67 100644
--- a/internal/lsp/cache/view.go
+++ b/internal/lsp/cache/view.go
@@ -611,7 +611,7 @@ func (s *snapshot) loadWorkspace(ctx context.Context, firstAttempt bool) {
 	// If we're loading anything, ensure we also load builtin.
 	// TODO(rstambler): explain the rationale for this.
 	if len(scopes) > 0 {
-		scopes = append(scopes, packagePath("builtin"))
+		scopes = append(scopes, PackagePath("builtin"))
 	}
 	err := s.load(ctx, firstAttempt, scopes...)
 
diff --git a/internal/lsp/source/view.go b/internal/lsp/source/view.go
index e5acf49f9e..19fca6e8cc 100644
--- a/internal/lsp/source/view.go
+++ b/internal/lsp/source/view.go
@@ -307,11 +307,11 @@ type TidiedModule struct {
 
 // Metadata represents package metadata retrieved from go/packages.
 type Metadata interface {
-	// Name is the package name.
-	Name() string
+	// PackageName is the package name.
+	PackageName() string
 
-	// PkgPath is the package path.
-	PkgPath() string
+	// PackagePath is the package path.
+	PackagePath() string
 }
 
 // Session represents a single connection from a client.
diff --git a/internal/lsp/source/workspace_symbol.go b/internal/lsp/source/workspace_symbol.go
index ecea2b4ace..1f6fd20895 100644
--- a/internal/lsp/source/workspace_symbol.go
+++ b/internal/lsp/source/workspace_symbol.go
@@ -75,7 +75,7 @@ type symbolizer func(name string, pkg Metadata, m matcherFunc) ([]string, float6
 func fullyQualifiedSymbolMatch(name string, pkg Metadata, matcher matcherFunc) ([]string, float64) {
 	_, score := dynamicSymbolMatch(name, pkg, matcher)
 	if score > 0 {
-		return []string{pkg.PkgPath(), ".", name}, score
+		return []string{pkg.PackagePath(), ".", name}, score
 	}
 	return nil, 0
 }
@@ -83,14 +83,14 @@ func fullyQualifiedSymbolMatch(name string, pkg Metadata, matcher matcherFunc) (
 func dynamicSymbolMatch(name string, pkg Metadata, matcher matcherFunc) ([]string, float64) {
 	var score float64
 
-	endsInPkgName := strings.HasSuffix(pkg.PkgPath(), pkg.Name())
+	endsInPkgName := strings.HasSuffix(pkg.PackagePath(), pkg.PackageName())
 
 	// If the package path does not end in the package name, we need to check the
 	// package-qualified symbol as an extra pass first.
 	if !endsInPkgName {
-		pkgQualified := []string{pkg.Name(), ".", name}
+		pkgQualified := []string{pkg.PackageName(), ".", name}
 		idx, score := matcher(pkgQualified)
-		nameStart := len(pkg.Name()) + 1
+		nameStart := len(pkg.PackageName()) + 1
 		if score > 0 {
 			// If our match is contained entirely within the unqualified portion,
 			// just return that.
@@ -103,11 +103,11 @@ func dynamicSymbolMatch(name string, pkg Metadata, matcher matcherFunc) ([]strin
 	}
 
 	// Now try matching the fully qualified symbol.
-	fullyQualified := []string{pkg.PkgPath(), ".", name}
+	fullyQualified := []string{pkg.PackagePath(), ".", name}
 	idx, score := matcher(fullyQualified)
 
 	// As above, check if we matched just the unqualified symbol name.
-	nameStart := len(pkg.PkgPath()) + 1
+	nameStart := len(pkg.PackagePath()) + 1
 	if idx >= nameStart {
 		return []string{name}, score
 	}
@@ -116,9 +116,9 @@ func dynamicSymbolMatch(name string, pkg Metadata, matcher matcherFunc) ([]strin
 	// initial pass above, so check if we matched just the package-qualified
 	// name.
 	if endsInPkgName && idx >= 0 {
-		pkgStart := len(pkg.PkgPath()) - len(pkg.Name())
+		pkgStart := len(pkg.PackagePath()) - len(pkg.PackageName())
 		if idx >= pkgStart {
-			return []string{pkg.Name(), ".", name}, score
+			return []string{pkg.PackageName(), ".", name}, score
 		}
 	}
 
@@ -128,7 +128,7 @@ func dynamicSymbolMatch(name string, pkg Metadata, matcher matcherFunc) ([]strin
 }
 
 func packageSymbolMatch(name string, pkg Metadata, matcher matcherFunc) ([]string, float64) {
-	qualified := []string{pkg.Name(), ".", name}
+	qualified := []string{pkg.PackageName(), ".", name}
 	if _, s := matcher(qualified); s > 0 {
 		return qualified, s
 	}
@@ -458,7 +458,7 @@ func (w *symbolWorker) matchFile(i symbolFile) {
 			kind:      sym.Kind,
 			uri:       i.uri,
 			rng:       sym.Range,
-			container: i.md.PkgPath(),
+			container: i.md.PackagePath(),
 		}
 		w.ss.store(si)
 	}