clerk @ 1b9e6e1

package lsp

import (

	"context"

	"time"

	"go.lsp.dev/jsonrpc2"

	"go.lsp.dev/protocol"

	"go.lsp.dev/uri"

	"olexsmir.xyz/clerk/internal/linter"

	"olexsmir.xyz/clerk/internal/lsp/lsputil"

)

const diagDebounce = 200 * time.Millisecond

func (s *server) scheduleDiagnostics(ctx context.Context) {

	s.mu.Lock()

	defer s.mu.Unlock()

	if s.diagCancel != nil {

		s.diagCancel()

	}

	ctx, cancel := context.WithCancel(context.Background())

	s.diagCancel = cancel

	time.AfterFunc(diagDebounce, func() {

		if ctx.Err() != nil {

			return

		}

		s.publishDiagnostics(jsonrpc2.DetachContext(ctx))

	})

}

func (s *server) publishDiagnostics(ctx context.Context) {

	s.log.Debug("publishing diagnostics")

	s.mu.RLock()

	var dirtyURIs []uri.URI

	for u, state := range s.openDocs {

		if state.dirty {

			dirtyURIs = append(dirtyURIs, u)

		}

	}

	s.mu.RUnlock()

	if len(dirtyURIs) == 0 {

		s.log.Debug("no dirty files")

		return

	}

	// Rebuild every dirty doc and publish the union of their files;

	// the same included file may appear in several trees and must be published once.

	s.mu.RLock()

	lintCfg := s.settings.Linter

	s.mu.RUnlock()

	lint, err := linter.NewLinter(lintCfg)

	if err != nil {

		s.log.Warn("building linter failed", "err", err)

		return

	}

	var finds []linter.Find

	lines := make(map[string]*lsputil.LineIndex)

	paths := make(map[string]bool)

	for _, u := range dirtyURIs {

		a := s.analysisFor(u)

		if a == nil {

			continue

		}

		var idx map[string]*lsputil.LineIndex

		if st, ok := s.getDocState(u); ok && st.cache != nil {

			idx = st.cache.fileIdx

		} else {

			idx = buildFileIdx(a)

		}

		for _, pf := range a.Files {

			lines[pf.Path] = idx[pf.Path]

			paths[pf.Path] = true

		}

		finds = append(finds, lint.Run(a)...)

	}

	if ctx.Err() != nil {

		return

	}

	s.assignSeverities(finds)

	diagsByFile := s.groupFindsByFile(dedupFinds(finds), lines)

	for fpath := range paths {

		if err := s.client.PublishDiagnostics(ctx, &protocol.PublishDiagnosticsParams{

			URI:         uri.File(fpath),

			Diagnostics: diagsByFile[fpath],

		}); err != nil {

			s.log.Warn("publish diagnostics failed", "uri", uri.File(fpath), "err", err)

		}

	}

	s.log.Debug("diagnostics published", "files", len(paths), "findings", len(finds))

}

func (s *server) groupFindsByFile(finds []linter.Find, lines map[string]*lsputil.LineIndex) map[string][]protocol.Diagnostic {

	// count per file to pre-size the diagnostic slices: append growth on ~10k

	// findings is the dominant allocation in the diagnostics path

	counts := make(map[string]int, len(finds))

	for _, find := range finds {

		if find.Span.File != "" {

			counts[find.Span.File]++

		}

	}

	diags := make(map[string][]protocol.Diagnostic, len(counts))

	for fpath, n := range counts {

		diags[fpath] = make([]protocol.Diagnostic, 0, n)

	}

	for _, find := range finds {

		file := find.Span.File

		if file == "" {

			continue

		}

		diags[file] = append(diags[file], s.findToDiagnostic(find, lines[file]))

	}

	return diags

}

func (s *server) findToDiagnostic(find linter.Find, lines *lsputil.LineIndex) protocol.Diagnostic {

	return protocol.Diagnostic{

		Range:    lines.SpanRange(find.Span),

		Severity: severityToLSP(find.Severity),

		Message:  protocol.String(find.Message),

		Source:   protocol.NewOptional(s.name),

		Code:     protocol.String(string(find.Code)),

	}

}

func dedupFinds(finds []linter.Find) []linter.Find {

	seen := make(map[findKey]bool, len(finds))

	dedup := make([]linter.Find, 0, len(finds))

	for _, f := range finds {

		k := findKey{f.Span.File, f.Span.Start.Line, f.Span.Start.Col, f.Code}

		if seen[k] {

			continue

		}

		seen[k] = true

		dedup = append(dedup, f)

	}

	return dedup

}

type findKey struct {

	file      string

	line, col int

	code      linter.RuleID

}

func (s *server) assignSeverities(finds []linter.Find) {

	s.mu.RLock()

	l := s.settings.Linter

	s.mu.RUnlock()

	for i := range finds {

		finds[i].Severity = l.SeverityFor(finds[i].Code)

	}

}

func severityToLSP(s linter.Severity) protocol.DiagnosticSeverity {

	switch s {

	case linter.SeverityError:

		return protocol.DiagnosticSeverityError

	case linter.SeverityWarning:

		return protocol.DiagnosticSeverityWarning

	case linter.SeverityInfo:

		return protocol.DiagnosticSeverityInformation

	case linter.SeverityHint:

		return protocol.DiagnosticSeverityHint

	default:

		panic("impossible diagnostic severity")

	}

}