clerk @ 1b9e6e1f8922a34b89b80ea1c5b55997326c3aa5

package lsp

import (

	"context"

	"strings"

	"go.lsp.dev/protocol"

	"go.lsp.dev/uri"

	"olexsmir.xyz/clerk/internal/analyzer"

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

	"olexsmir.xyz/clerk/journal"

	"olexsmir.xyz/clerk/journal/ast"

	"olexsmir.xyz/clerk/journal/lexer"

	"olexsmir.xyz/clerk/journal/parser"

)

func (s *server) DidOpen(ctx context.Context, params *protocol.DidOpenTextDocumentParams) error {

	s.openDoc(params.TextDocument.URI, params.TextDocument.Text, params.TextDocument.Version, params.TextDocument.LanguageID)

	s.scheduleDiagnostics(ctx)

	return nil

}

func (s *server) DidChange(ctx context.Context, params *protocol.DidChangeTextDocumentParams) error {

	s.updateDoc(params.TextDocument.URI, params.TextDocument.Version, params.ContentChanges)

	s.scheduleDiagnostics(ctx)

	return nil

}

func (s *server) DidClose(ctx context.Context, params *protocol.DidCloseTextDocumentParams) error {

	u := params.TextDocument.URI

	s.closeDoc(u)

	s.loader.Evict(u.Path())

	// clear closed doc's diagnostics; dependents rebuild from disk since the buffer text is gone.

	s.markDependentsDirty(u)

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

		URI:         u,

		Diagnostics: []protocol.Diagnostic{},

	}); err != nil {

		s.log.Warn("clear diagnostics failed", "uri", u, "err", err)

	}

	s.scheduleDiagnostics(ctx)

	return nil

}

func (s *server) DidSave(ctx context.Context, params *protocol.DidSaveTextDocumentParams) error {

	return nil

}

// Document management

type docState struct {

	text       string

	version    int32

	languageID protocol.LanguageKind

	lineIdx    *lsputil.LineIndex // cached line index for the text

	dirty bool           // true while the cached analysis may not reflect the current text

	cache *analysisCache // nil until first build

	sem   *semCache      // nil until first tokenize

}

type analysisCache struct {

	analysis *analyzer.Analysis

	fileIdx  map[string]*lsputil.LineIndex

	paths    map[string]bool

}

func newAnalysisCache(an *analyzer.Analysis) *analysisCache {

	paths := make(map[string]bool, len(an.Files))

	for _, pf := range an.Files {

		paths[journal.CanonicalPath(pf.Path)] = true

	}

	return &analysisCache{analysis: an, paths: paths, fileIdx: buildFileIdx(an)}

}

func buildFileIdx(an *analyzer.Analysis) map[string]*lsputil.LineIndex {

	idx := make(map[string]*lsputil.LineIndex, len(an.Files))

	for _, pf := range an.Files {

		idx[pf.Path] = lsputil.NewLineIndex(string(pf.Src))

	}

	return idx

}

func (s *server) openDoc(u uri.URI, text string, version int32, langID protocol.LanguageKind) {

	s.mu.Lock()

	s.openDocs[u] = docState{

		text:       text,

		version:    version,

		languageID: langID,

		lineIdx:    lsputil.NewLineIndex(text),

		dirty:      true,

	}

	s.mu.Unlock()

}

func (s *server) updateDoc(u uri.URI, version int32, changes []protocol.TextDocumentContentChangeEvent) {

	s.mu.Lock()

	state, ok := s.openDocs[u]

	if !ok {

		s.mu.Unlock()

		return

	}

	state.version = version

	incremental := len(changes) == 1

	var edit semEdit

	for _, ch := range changes {

		switch ev := ch.(type) {

		case *protocol.TextDocumentContentChangeWholeDocument:

			incremental = false

			state.text = ev.Text

		case *protocol.TextDocumentContentChangePartial:

			if state.sem == nil || state.sem.pending != nil {

				incremental = false

			}

			if state.lineIdx == nil {

				state.lineIdx = lsputil.NewLineIndex(state.text)

			}

			start := state.lineIdx.Offset(int(ev.Range.Start.Line), int(ev.Range.Start.Character))

			end := state.lineIdx.Offset(int(ev.Range.End.Line), int(ev.Range.End.Character))

			removed := state.text[start:end]

			state.text = state.text[:start] + ev.Text + state.text[end:]

			if incremental {

				edit = semEdit{

					start:     start,

					oldEnd:    end,

					newEnd:    start + len(ev.Text),

					deltaLine: strings.Count(ev.Text, "\n") - strings.Count(removed, "\n"),

				}

			}

		}

		state.lineIdx = lsputil.NewLineIndex(state.text)

	}

	state.cache = nil

	state.dirty = true

	if incremental {

		state.sem.pending = &edit

	} else {

		state.sem = nil

	}

	s.openDocs[u] = state

	s.mu.Unlock()

	s.markDependentsDirty(u)

}

// markDependentsDirty dirties every open doc whose cached analysis includes u,

// e.g. after u is edited or closed.

func (s *server) markDependentsDirty(u uri.URI) {

	canon := journal.CanonicalPath(u.Path())

	s.mu.Lock()

	for du, dstate := range s.openDocs {

		if dstate.cache == nil {

			continue

		}

		if dstate.cache.paths[canon] {

			dstate.dirty = true

			s.openDocs[du] = dstate

		}

	}

	s.mu.Unlock()

}

func (s *server) getDocState(u uri.URI) (docState, bool) {

	s.mu.RLock()

	state, ok := s.openDocs[u]

	s.mu.RUnlock()

	return state, ok

}

func (s *server) closeDoc(u uri.URI) {

	s.mu.Lock()

	delete(s.openDocs, u)

	s.mu.Unlock()

}

func parseJournalStr(content string) *ast.Journal {

	l := lexer.New("", []byte(content))

	p := parser.New(l)

	return p.ParseJournal()

}