internal/golangorgx: cuelsp: remove Go-specific analysis

None of this code is needed for cuelsp. Some of it may need to be
resurrected at some point in the future, but at a minimum it'll need to
be rewritten to adapt it to cue.

Change-Id: I495996fd6f2a1d1d07cc1c0bf054b1e852b1847b
Signed-off-by: Matthew Sackman <[email protected]>
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/1214778
Unity-Result: CUE porcuepine <[email protected]>
Reviewed-by: Daniel Martí <[email protected]>
TryBot-Result: CUEcueckoo <[email protected]>

Author: cuematthew

internal/golangorgx/gopls/cache/analysis.go

@@ -25,22 +25,18 @@ import (
 	"runtime"
 	"runtime/debug"
 	"sort"
-	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
 
 	"cuelang.org/go/internal/golangorgx/gopls/cache/metadata"
 	"cuelang.org/go/internal/golangorgx/gopls/file"
 	"cuelang.org/go/internal/golangorgx/gopls/filecache"
-	"cuelang.org/go/internal/golangorgx/gopls/progress"
 	"cuelang.org/go/internal/golangorgx/gopls/protocol"
-	"cuelang.org/go/internal/golangorgx/gopls/settings"
 	"cuelang.org/go/internal/golangorgx/gopls/util/astutil"
 	"cuelang.org/go/internal/golangorgx/gopls/util/bug"
 	"cuelang.org/go/internal/golangorgx/gopls/util/frob"
 	"cuelang.org/go/internal/golangorgx/tools/event"
-	"cuelang.org/go/internal/golangorgx/tools/event/tag"
 	"cuelang.org/go/internal/golangorgx/tools/facts"
 	"cuelang.org/go/internal/golangorgx/tools/gcimporter"
 	"cuelang.org/go/internal/golangorgx/tools/typesinternal"
@@ -166,314 +162,6 @@ import (
 // feature.
 const AnalysisProgressTitle = "Analyzing Dependencies"
 
-// Analyze applies a set of analyzers to the package denoted by id,
-// and returns their diagnostics for that package.
-//
-// The analyzers list must be duplicate free; order does not matter.
-//
-// Notifications of progress may be sent to the optional reporter.
-func (s *Snapshot) Analyze(ctx context.Context, pkgs map[PackageID]*metadata.Package, analyzers []*settings.Analyzer, reporter *progress.Tracker) ([]*Diagnostic, error) {
-	start := time.Now() // for progress reporting
-
-	var tagStr string // sorted comma-separated list of PackageIDs
-	{
-		// TODO(adonovan): replace with a generic map[S]any -> string
-		// function in the tag package, and use maps.Keys + slices.Sort.
-		keys := make([]string, 0, len(pkgs))
-		for id := range pkgs {
-			keys = append(keys, string(id))
-		}
-		sort.Strings(keys)
-		tagStr = strings.Join(keys, ",")
-	}
-	ctx, done := event.Start(ctx, "snapshot.Analyze", tag.Package.Of(tagStr))
-	defer done()
-
-	// Filter and sort enabled root analyzers.
-	// A disabled analyzer may still be run if required by another.
-	toSrc := make(map[*analysis.Analyzer]*settings.Analyzer)
-	var enabled []*analysis.Analyzer // enabled subset + transitive requirements
-	for _, a := range analyzers {
-		if a.IsEnabled(s.Options()) {
-			toSrc[a.Analyzer] = a
-			enabled = append(enabled, a.Analyzer)
-		}
-	}
-	sort.Slice(enabled, func(i, j int) bool {
-		return enabled[i].Name < enabled[j].Name
-	})
-	analyzers = nil // prevent accidental use
-
-	enabled = requiredAnalyzers(enabled)
-
-	// Perform basic sanity checks.
-	// (Ideally we would do this only once.)
-	if err := analysis.Validate(enabled); err != nil {
-		return nil, fmt.Errorf("invalid analyzer configuration: %v", err)
-	}
-
-	stableNames := make(map[*analysis.Analyzer]string)
-
-	var facty []*analysis.Analyzer // facty subset of enabled + transitive requirements
-	for _, a := range enabled {
-		// TODO(adonovan): reject duplicate stable names (very unlikely).
-		stableNames[a] = stableName(a)
-
-		// Register fact types of all required analyzers.
-		if len(a.FactTypes) > 0 {
-			facty = append(facty, a)
-			for _, f := range a.FactTypes {
-				gob.Register(f) // <2us
-			}
-		}
-	}
-	facty = requiredAnalyzers(facty)
-
-	// File set for this batch (entire graph) of analysis.
-	fset := token.NewFileSet()
-
-	// Starting from the root packages and following DepsByPkgPath,
-	// build the DAG of packages we're going to analyze.
-	//
-	// Root nodes will run the enabled set of analyzers,
-	// whereas dependencies will run only the facty set.
-	// Because (by construction) enabled is a superset of facty,
-	// we can analyze each node with exactly one set of analyzers.
-	nodes := make(map[PackageID]*analysisNode)
-	var leaves []*analysisNode // nodes with no unfinished successors
-	var makeNode func(from *analysisNode, id PackageID) (*analysisNode, error)
-	makeNode = func(from *analysisNode, id PackageID) (*analysisNode, error) {
-		an, ok := nodes[id]
-		if !ok {
-			mp := s.Metadata(id)
-			if mp == nil {
-				return nil, bug.Errorf("no metadata for %s", id)
-			}
-
-			// -- preorder --
-
-			an = &analysisNode{
-				fset:        fset,
-				mp:          mp,
-				analyzers:   facty, // all nodes run at least the facty analyzers
-				allDeps:     make(map[PackagePath]*analysisNode),
-				exportDeps:  make(map[PackagePath]*analysisNode),
-				stableNames: stableNames,
-			}
-			nodes[id] = an
-
-			// -- recursion --
-
-			// Build subgraphs for dependencies.
-			an.succs = make(map[PackageID]*analysisNode, len(mp.DepsByPkgPath))
-			for _, depID := range mp.DepsByPkgPath {
-				dep, err := makeNode(an, depID)
-				if err != nil {
-					return nil, err
-				}
-				an.succs[depID] = dep
-
-				// Compute the union of all dependencies.
-				// (This step has quadratic complexity.)
-				for pkgPath, node := range dep.allDeps {
-					an.allDeps[pkgPath] = node
-				}
-			}
-
-			// -- postorder --
-
-			an.allDeps[mp.PkgPath] = an // add self entry (reflexive transitive closure)
-
-			// Add leaf nodes (no successors) directly to queue.
-			if len(an.succs) == 0 {
-				leaves = append(leaves, an)
-			}
-
-			// Load the contents of each compiled Go file through
-			// the snapshot's cache. (These are all cache hits as
-			// files are pre-loaded following packages.Load)
-			an.files = make([]file.Handle, len(mp.CompiledGoFiles))
-			for i, uri := range mp.CompiledGoFiles {
-				fh, err := s.ReadFile(ctx, uri)
-				if err != nil {
-					return nil, err
-				}
-				an.files[i] = fh
-			}
-		}
-		// Add edge from predecessor.
-		if from != nil {
-			atomic.AddInt32(&from.unfinishedSuccs, 1) // TODO(adonovan): use generics
-			an.preds = append(an.preds, from)
-		}
-		atomic.AddInt32(&an.unfinishedPreds, 1)
-		return an, nil
-	}
-
-	// For root packages, we run the enabled set of analyzers.
-	var roots []*analysisNode
-	for id := range pkgs {
-		root, err := makeNode(nil, id)
-		if err != nil {
-			return nil, err
-		}
-		root.analyzers = enabled
-		roots = append(roots, root)
-	}
-
-	// Now that we have read all files,
-	// we no longer need the snapshot.
-	// (but options are needed for progress reporting)
-	options := s.Options()
-	s = nil
-
-	// Progress reporting. If supported, gopls reports progress on analysis
-	// passes that are taking a long time.
-	maybeReport := func(completed int64) {}
-
-	// Enable progress reporting if enabled by the user
-	// and we have a capable reporter.
-	if reporter != nil && reporter.SupportsWorkDoneProgress() && options.AnalysisProgressReporting {
-		var reportAfter = options.ReportAnalysisProgressAfter // tests may set this to 0
-		const reportEvery = 1 * time.Second
-
-		ctx, cancel := context.WithCancel(ctx)
-		defer cancel()
-
-		var (
-			reportMu   sync.Mutex
-			lastReport time.Time
-			wd         *progress.WorkDone
-		)
-		defer func() {
-			reportMu.Lock()
-			defer reportMu.Unlock()
-
-			if wd != nil {
-				wd.End(ctx, "Done.") // ensure that the progress report exits
-			}
-		}()
-		maybeReport = func(completed int64) {
-			now := time.Now()
-			if now.Sub(start) < reportAfter {
-				return
-			}
-
-			reportMu.Lock()
-			defer reportMu.Unlock()
-
-			if wd == nil {
-				wd = reporter.Start(ctx, AnalysisProgressTitle, "", nil, cancel)
-			}
-
-			if now.Sub(lastReport) > reportEvery {
-				lastReport = now
-				// Trailing space is intentional: some LSP clients strip newlines.
-				msg := fmt.Sprintf(`Indexed %d/%d packages. (Set "analysisProgressReporting" to false to disable notifications.)`,
-					completed, len(nodes))
-				pct := 100 * float64(completed) / float64(len(nodes))
-				wd.Report(ctx, msg, pct)
-			}
-		}
-	}
-
-	// Execute phase: run leaves first, adding
-	// new nodes to the queue as they become leaves.
-	var g errgroup.Group
-
-	// Analysis is CPU-bound.
-	//
-	// Note: avoid g.SetLimit here: it makes g.Go stop accepting work, which
-	// prevents workers from enqeuing, and thus finishing, and thus allowing the
-	// group to make progress: deadlock.
-	limiter := make(chan unit, runtime.GOMAXPROCS(0))
-	var completed int64
-
-	var enqueue func(*analysisNode)
-	enqueue = func(an *analysisNode) {
-		g.Go(func() error {
-			limiter <- unit{}
-			defer func() { <-limiter }()
-
-			summary, err := an.runCached(ctx)
-			if err != nil {
-				return err // cancelled, or failed to produce a package
-			}
-			maybeReport(atomic.AddInt64(&completed, 1))
-			an.summary = summary
-
-			// Notify each waiting predecessor,
-			// and enqueue it when it becomes a leaf.
-			for _, pred := range an.preds {
-				if atomic.AddInt32(&pred.unfinishedSuccs, -1) == 0 {
-					enqueue(pred)
-				}
-			}
-
-			// Notify each successor that we no longer need
-			// its action summaries, which hold Result values.
-			// After the last one, delete it, so that we
-			// free up large results such as SSA.
-			for _, succ := range an.succs {
-				succ.decrefPreds()
-			}
-			return nil
-		})
-	}
-	for _, leaf := range leaves {
-		enqueue(leaf)
-	}
-	if err := g.Wait(); err != nil {
-		return nil, err // cancelled, or failed to produce a package
-	}
-
-	// Report diagnostics only from enabled actions that succeeded.
-	// Errors from creating or analyzing packages are ignored.
-	// Diagnostics are reported in the order of the analyzers argument.
-	//
-	// TODO(adonovan): ignoring action errors gives the caller no way
-	// to distinguish "there are no problems in this code" from
-	// "the code (or analyzers!) are so broken that we couldn't even
-	// begin the analysis you asked for".
-	// Even if current callers choose to discard the
-	// results, we should propagate the per-action errors.
-	var results []*Diagnostic
-	for _, root := range roots {
-		for _, a := range enabled {
-			// Skip analyzers that were added only to
-			// fulfil requirements of the original set.
-			srcAnalyzer, ok := toSrc[a]
-			if !ok {
-				// Although this 'skip' operation is logically sound,
-				// it is nonetheless surprising that its absence should
-				// cause #60909 since none of the analyzers currently added for
-				// requirements (e.g. ctrlflow, inspect, buildssa)
-				// is capable of reporting diagnostics.
-				if summary := root.summary.Actions[stableNames[a]]; summary != nil {
-					if n := len(summary.Diagnostics); n > 0 {
-						bug.Reportf("Internal error: got %d unexpected diagnostics from analyzer %s. This analyzer was added only to fulfil the requirements of the requested set of analyzers, and it is not expected that such analyzers report diagnostics. Please report this in issue #60909.", n, a)
-					}
-				}
-				continue
-			}
-
-			// Inv: root.summary is the successful result of run (via runCached).
-			summary, ok := root.summary.Actions[stableNames[a]]
-			if summary == nil {
-				panic(fmt.Sprintf("analyzeSummary.Actions[%q] = (nil, %t); got %v (#60551)",
-					stableNames[a], ok, root.summary.Actions))
-			}
-			if summary.Err != "" {
-				continue // action failed
-			}
-			for _, gobDiag := range summary.Diagnostics {
-				results = append(results, toSourceDiagnostic(srcAnalyzer, &gobDiag))
-			}
-		}
-	}
-	return results, nil
-}
-
 func (an *analysisNode) decrefPreds() {
 	if atomic.AddInt32(&an.unfinishedPreds, -1) == 0 {
 		an.summary.Actions = nil