diff --git a/internal/lsp/cache/load.go b/internal/lsp/cache/load.go
index 890b738..27cd534 100644
--- a/internal/lsp/cache/load.go
+++ b/internal/lsp/cache/load.go
@@ -175,7 +175,12 @@
 		event.Log(ctx, "go/packages.Load", tag.Snapshot.Of(s.ID()), tag.Directory.Of(cfg.Dir), tag.Query.Of(query), tag.PackageCount.Of(len(pkgs)))
 	}
 	if len(pkgs) == 0 {
-		if err == nil {
+		if err != nil {
+			// Try to extract the error into a diagnostic.
+			if srcErrs := s.parseLoadError(ctx, err); srcErrs != nil {
+				return srcErrs
+			}
+		} else {
 			err = fmt.Errorf("no packages returned")
 		}
 		return errors.Errorf("%v: %w", err, source.PackagesLoadError)
@@ -215,6 +220,25 @@
 	return nil
 }
 
+func (s *snapshot) parseLoadError(ctx context.Context, loadErr error) *source.ErrorList {
+	var srcErrs *source.ErrorList
+	for _, uri := range s.ModFiles() {
+		fh, err := s.GetFile(ctx, uri)
+		if err != nil {
+			continue
+		}
+		srcErr := extractGoCommandError(ctx, s, fh, loadErr)
+		if srcErr == nil {
+			continue
+		}
+		if srcErrs == nil {
+			srcErrs = &source.ErrorList{}
+		}
+		*srcErrs = append(*srcErrs, srcErr)
+	}
+	return srcErrs
+}
+
 // tempWorkspaceModule creates a temporary directory for use with
 // packages.Loads that occur from within the workspace module.
 func (s *snapshot) tempWorkspaceModule(ctx context.Context) (_ span.URI, cleanup func(), err error) {
diff --git a/internal/lsp/cache/mod.go b/internal/lsp/cache/mod.go
index 50c94f7..099b5ce 100644
--- a/internal/lsp/cache/mod.go
+++ b/internal/lsp/cache/mod.go
@@ -14,8 +14,10 @@
 	"regexp"
 	"strconv"
 	"strings"
+	"unicode"
 
 	"golang.org/x/mod/modfile"
+	"golang.org/x/mod/module"
 	"golang.org/x/tools/internal/event"
 	"golang.org/x/tools/internal/lsp/debug/tag"
 	"golang.org/x/tools/internal/lsp/protocol"
@@ -375,3 +377,82 @@
 	}
 	return f.IsDir()
 }
+
+var moduleAtVersionRe = regexp.MustCompile(`^(?P<module>.*)@(?P<version>.*)$`)
+
+// ExtractGoCommandError tries to parse errors that come from the go command
+// and shape them into go.mod diagnostics.
+func extractGoCommandError(ctx context.Context, snapshot source.Snapshot, fh source.FileHandle, loadErr error) *source.Error {
+	// We try to match module versions in error messages. Some examples:
+	//
+	//  example.com@v1.2.2: reading example.com/@v/v1.2.2.mod: no such file or directory
+	//  go: github.com/cockroachdb/apd/v2@v2.0.72: reading github.com/cockroachdb/apd/go.mod at revision v2.0.72: unknown revision v2.0.72
+	//  go: example.com@v1.2.3 requires\n\trandom.org@v1.2.3: parsing go.mod:\n\tmodule declares its path as: bob.org\n\tbut was required as: random.org
+	//
+	// We split on colons and whitespace, and attempt to match on something
+	// that matches module@version. If we're able to find a match, we try to
+	// find anything that matches it in the go.mod file.
+	var v module.Version
+	fields := strings.FieldsFunc(loadErr.Error(), func(r rune) bool {
+		return unicode.IsSpace(r) || r == ':'
+	})
+	for _, s := range fields {
+		s = strings.TrimSpace(s)
+		match := moduleAtVersionRe.FindStringSubmatch(s)
+		if match == nil || len(match) < 3 {
+			continue
+		}
+		path, version := match[1], match[2]
+		// Any module versions that come from the workspace module should not
+		// be shown to the user.
+		if source.IsWorkspaceModuleVersion(version) {
+			continue
+		}
+		if err := module.Check(path, version); err != nil {
+			continue
+		}
+		v.Path, v.Version = path, version
+		break
+	}
+	pm, err := snapshot.ParseMod(ctx, fh)
+	if err != nil {
+		return nil
+	}
+	toSourceError := func(line *modfile.Line) *source.Error {
+		rng, err := rangeFromPositions(pm.Mapper, line.Start, line.End)
+		if err != nil {
+			return nil
+		}
+		return &source.Error{
+			Message: loadErr.Error(),
+			Range:   rng,
+			URI:     fh.URI(),
+		}
+	}
+	// Check if there are any require, exclude, or replace statements that
+	// match this module version.
+	for _, req := range pm.File.Require {
+		if req.Mod != v {
+			continue
+		}
+		return toSourceError(req.Syntax)
+	}
+	for _, ex := range pm.File.Exclude {
+		if ex.Mod != v {
+			continue
+		}
+		return toSourceError(ex.Syntax)
+	}
+	for _, rep := range pm.File.Replace {
+		if rep.New != v && rep.Old != v {
+			continue
+		}
+		return toSourceError(rep.Syntax)
+	}
+	// No match for the module path was found in the go.mod file.
+	// Show the error on the module declaration, if one exists.
+	if pm.File.Module == nil {
+		return nil
+	}
+	return toSourceError(pm.File.Module.Syntax)
+}
diff --git a/internal/lsp/diagnostics.go b/internal/lsp/diagnostics.go
index 5360612..f3e59c6 100644
--- a/internal/lsp/diagnostics.go
+++ b/internal/lsp/diagnostics.go
@@ -513,29 +513,5 @@
 		}
 		return true
 	}
-	// If there is a go.mod-related error, as well as a workspace load error,
-	// there is likely an issue with the go.mod file. Try to parse the error
-	// message and create a diagnostic.
-	if modErr == nil {
-		return false
-	}
-	if errors.Is(loadErr, source.PackagesLoadError) {
-		// TODO(rstambler): Construct the diagnostics in internal/lsp/cache
-		// so that we can avoid this here.
-		reports := new(reportSet)
-		for _, uri := range snapshot.ModFiles() {
-			fh, err := snapshot.GetFile(ctx, uri)
-			if err != nil {
-				return false
-			}
-			diag, err := mod.ExtractGoCommandError(ctx, snapshot, fh, loadErr)
-			if err != nil {
-				return false
-			}
-			reports.add(fh.VersionedFileIdentity(), false, diag)
-			s.publishReports(ctx, snapshot, reports)
-			return true
-		}
-	}
 	return false
 }
diff --git a/internal/lsp/mod/diagnostics.go b/internal/lsp/mod/diagnostics.go
index b834c7e..e8c4533 100644
--- a/internal/lsp/mod/diagnostics.go
+++ b/internal/lsp/mod/diagnostics.go
@@ -8,18 +8,11 @@
 
 import (
 	"context"
-	"fmt"
-	"regexp"
-	"strings"
-	"unicode"
 
-	"golang.org/x/mod/modfile"
-	"golang.org/x/mod/module"
 	"golang.org/x/tools/internal/event"
 	"golang.org/x/tools/internal/lsp/debug/tag"
 	"golang.org/x/tools/internal/lsp/protocol"
 	"golang.org/x/tools/internal/lsp/source"
-	"golang.org/x/tools/internal/span"
 )
 
 func Diagnostics(ctx context.Context, snapshot source.Snapshot) (map[source.VersionedFileIdentity][]*source.Diagnostic, error) {
@@ -60,101 +53,3 @@
 	}
 	return reports, nil
 }
-
-var moduleAtVersionRe = regexp.MustCompile(`^(?P<module>.*)@(?P<version>.*)$`)
-
-// ExtractGoCommandError tries to parse errors that come from the go command
-// and shape them into go.mod diagnostics.
-func ExtractGoCommandError(ctx context.Context, snapshot source.Snapshot, fh source.FileHandle, loadErr error) (*source.Diagnostic, error) {
-	// We try to match module versions in error messages. Some examples:
-	//
-	//  example.com@v1.2.2: reading example.com/@v/v1.2.2.mod: no such file or directory
-	//  go: github.com/cockroachdb/apd/v2@v2.0.72: reading github.com/cockroachdb/apd/go.mod at revision v2.0.72: unknown revision v2.0.72
-	//  go: example.com@v1.2.3 requires\n\trandom.org@v1.2.3: parsing go.mod:\n\tmodule declares its path as: bob.org\n\tbut was required as: random.org
-	//
-	// We split on colons and whitespace, and attempt to match on something
-	// that matches module@version. If we're able to find a match, we try to
-	// find anything that matches it in the go.mod file.
-	var v module.Version
-	fields := strings.FieldsFunc(loadErr.Error(), func(r rune) bool {
-		return unicode.IsSpace(r) || r == ':'
-	})
-	for _, s := range fields {
-		s = strings.TrimSpace(s)
-		match := moduleAtVersionRe.FindStringSubmatch(s)
-		if match == nil || len(match) < 3 {
-			continue
-		}
-		path, version := match[1], match[2]
-		// Any module versions that come from the workspace module should not
-		// be shown to the user.
-		if source.IsWorkspaceModuleVersion(version) {
-			continue
-		}
-		if err := module.Check(path, version); err != nil {
-			continue
-		}
-		v.Path, v.Version = path, version
-		break
-	}
-	pm, err := snapshot.ParseMod(ctx, fh)
-	if err != nil {
-		return nil, err
-	}
-	toDiagnostic := func(line *modfile.Line) (*source.Diagnostic, error) {
-		rng, err := rangeFromPositions(fh.URI(), pm.Mapper, line.Start, line.End)
-		if err != nil {
-			return nil, err
-		}
-		return &source.Diagnostic{
-			Message:  loadErr.Error(),
-			Range:    rng,
-			Severity: protocol.SeverityError,
-		}, nil
-	}
-	// Check if there are any require, exclude, or replace statements that
-	// match this module version.
-	for _, req := range pm.File.Require {
-		if req.Mod != v {
-			continue
-		}
-		return toDiagnostic(req.Syntax)
-	}
-	for _, ex := range pm.File.Exclude {
-		if ex.Mod != v {
-			continue
-		}
-		return toDiagnostic(ex.Syntax)
-	}
-	for _, rep := range pm.File.Replace {
-		if rep.New != v && rep.Old != v {
-			continue
-		}
-		return toDiagnostic(rep.Syntax)
-	}
-	// No match for the module path was found in the go.mod file.
-	// Show the error on the module declaration, if one exists.
-	if pm.File.Module == nil {
-		return nil, fmt.Errorf("no module declaration in %s", fh.URI())
-	}
-	return toDiagnostic(pm.File.Module.Syntax)
-}
-
-func rangeFromPositions(uri span.URI, m *protocol.ColumnMapper, s, e modfile.Position) (protocol.Range, error) {
-	toPoint := func(offset int) (span.Point, error) {
-		l, c, err := m.Converter.ToPosition(offset)
-		if err != nil {
-			return span.Point{}, err
-		}
-		return span.NewPoint(l, c, offset), nil
-	}
-	start, err := toPoint(s.Byte)
-	if err != nil {
-		return protocol.Range{}, err
-	}
-	end, err := toPoint(e.Byte)
-	if err != nil {
-		return protocol.Range{}, err
-	}
-	return m.Range(span.New(uri, start, end))
-}