implements PLN-0063
This commit is contained in:
-27
@@ -1,27 +0,0 @@
|
||||
package p.studio.lsp;
|
||||
|
||||
import p.studio.lsp.dtos.LspSessionStateDTO;
|
||||
import p.studio.lsp.messages.LspAnalyzeDocumentRequest;
|
||||
import p.studio.lsp.messages.LspAnalyzeDocumentResult;
|
||||
import p.studio.lsp.messages.SemanticSession;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import static p.studio.lsp.LspSemanticUtilities.normalize;
|
||||
|
||||
class LspSemanticAnalyseService {
|
||||
LspAnalyzeDocumentResult analyze(
|
||||
final SemanticSession session,
|
||||
final LspAnalyzeDocumentRequest request) {
|
||||
final var normalizedRequestedDocument = normalize(request.documentPath());
|
||||
return new LspAnalyzeDocumentResult(
|
||||
new LspSessionStateDTO(true, List.of("diagnostics", "symbols", "definition", "highlight", "structural-anchors")),
|
||||
session.semanticPresentation(),
|
||||
session.diagnosticsByDocument().getOrDefault(normalizedRequestedDocument, List.of()),
|
||||
session.semanticHighlightsByDocument().getOrDefault(normalizedRequestedDocument, List.of()),
|
||||
session.inlineHintsByDocument().getOrDefault(normalizedRequestedDocument, List.of()),
|
||||
session.documentSymbolsByDocument().getOrDefault(normalizedRequestedDocument, List.of()),
|
||||
session.structuralAnchorsByDocument().getOrDefault(normalizedRequestedDocument, List.of()),
|
||||
session.workspaceSymbols());
|
||||
}
|
||||
}
|
||||
-46
@@ -1,46 +0,0 @@
|
||||
package p.studio.lsp;
|
||||
|
||||
import p.studio.compiler.pbs.lexer.PbsToken;
|
||||
import p.studio.compiler.pbs.lexer.PbsTokenKind;
|
||||
import p.studio.lsp.dtos.LspDefinitionTargetDTO;
|
||||
import p.studio.lsp.dtos.LspSymbolDTO;
|
||||
import p.studio.lsp.messages.LspDefinitionRequest;
|
||||
import p.studio.lsp.messages.LspDefinitionResult;
|
||||
import p.studio.lsp.messages.SemanticSession;
|
||||
|
||||
import java.nio.file.Path;
|
||||
import java.util.List;
|
||||
|
||||
import static p.studio.lsp.LspSemanticUtilities.normalize;
|
||||
import static p.studio.lsp.LspSemanticUtilities.tokenAt;
|
||||
|
||||
class LspSemanticDefinitionService {
|
||||
|
||||
LspDefinitionResult definition(
|
||||
final SemanticSession session,
|
||||
final LspDefinitionRequest request) {
|
||||
final List<LspDefinitionTargetDTO> targets = resolveDefinitionTargets(session, request);
|
||||
return new LspDefinitionResult(request.documentPath(), request.offset(), targets);
|
||||
}
|
||||
|
||||
private List<LspDefinitionTargetDTO> resolveDefinitionTargets(
|
||||
final SemanticSession session,
|
||||
final LspDefinitionRequest request) {
|
||||
final Path documentPath = normalize(request.documentPath());
|
||||
final List<PbsToken> tokens = session.tokensByDocument().getOrDefault(documentPath, List.of());
|
||||
final PbsToken activeToken = tokenAt(tokens, request.offset());
|
||||
if (activeToken == null || activeToken.kind() != PbsTokenKind.IDENTIFIER) {
|
||||
return List.of();
|
||||
}
|
||||
final String lexeme = activeToken.lexeme();
|
||||
final List<LspSymbolDTO> sameDocumentMatches = session.symbolsByName().getOrDefault(lexeme, List.of()).stream()
|
||||
.filter(symbol -> symbol.documentPath().equals(documentPath))
|
||||
.toList();
|
||||
final List<LspSymbolDTO> effectiveMatches = sameDocumentMatches.isEmpty()
|
||||
? session.symbolsByName().getOrDefault(lexeme, List.of())
|
||||
: sameDocumentMatches;
|
||||
return effectiveMatches.stream()
|
||||
.map(symbol -> new LspDefinitionTargetDTO(symbol.name(), symbol.documentPath(), symbol.range()))
|
||||
.toList();
|
||||
}
|
||||
}
|
||||
@@ -1,353 +0,0 @@
|
||||
package p.studio.lsp;
|
||||
|
||||
import p.studio.compiler.FrontendRegistryService;
|
||||
import p.studio.compiler.messages.*;
|
||||
import p.studio.compiler.models.AnalysisSnapshot;
|
||||
import p.studio.compiler.models.BuilderPipelineContext;
|
||||
import p.studio.compiler.models.FrontendSpec;
|
||||
import p.studio.compiler.models.FrontendSemanticPresentationSpec;
|
||||
import p.studio.compiler.models.SourceHandle;
|
||||
import p.studio.compiler.pbs.ast.PbsAst;
|
||||
import p.studio.compiler.pbs.lexer.PbsLexer;
|
||||
import p.studio.compiler.pbs.parser.PbsParser;
|
||||
import p.studio.compiler.source.diagnostics.Diagnostic;
|
||||
import p.studio.compiler.source.diagnostics.DiagnosticSink;
|
||||
import p.studio.compiler.source.identifiers.FileId;
|
||||
import p.studio.compiler.services.PBSFrontendPhaseService;
|
||||
import p.studio.compiler.services.PbsInlineHintSurface;
|
||||
import p.studio.compiler.workspaces.AssetSurfaceContextLoader;
|
||||
import p.studio.compiler.workspaces.PipelineStage;
|
||||
import p.studio.compiler.workspaces.stages.LoadSourcesPipelineStage;
|
||||
import p.studio.compiler.workspaces.stages.ResolveDepsPipelineStage;
|
||||
import p.studio.lsp.dtos.LspDiagnosticDTO;
|
||||
import p.studio.lsp.dtos.LspInlineHintDTO;
|
||||
import p.studio.lsp.dtos.LspRangeDTO;
|
||||
import p.studio.lsp.dtos.LspSemanticPresentationDTO;
|
||||
import p.studio.lsp.messages.*;
|
||||
import p.studio.lsp.models.AnalysisRuntimeSnapshot;
|
||||
import p.studio.lsp.models.SemanticIndex;
|
||||
import p.studio.utilities.logs.LogAggregator;
|
||||
import p.studio.vfs.VfsProjectDocument;
|
||||
|
||||
import java.nio.file.Path;
|
||||
import java.util.ArrayList;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import static p.studio.lsp.LspSemanticUtilities.*;
|
||||
|
||||
final class LspSemanticReadPhase {
|
||||
private final LspSemanticAnalyseService analyseService;
|
||||
private final LspSemanticDefinitionService definitionService;
|
||||
|
||||
LspSemanticReadPhase() {
|
||||
this.analyseService = new LspSemanticAnalyseService();
|
||||
this.definitionService = new LspSemanticDefinitionService();
|
||||
}
|
||||
|
||||
public LspAnalyzeDocumentResult analyze(
|
||||
final LspProjectContext projectContext,
|
||||
final VfsProjectDocument vfsProjectDocument,
|
||||
final LspAnalyzeDocumentRequest request) {
|
||||
final var session = buildSession(projectContext, vfsProjectDocument, request.documentPath());
|
||||
return analyseService.analyze(session, request);
|
||||
}
|
||||
|
||||
public LspDefinitionResult definition(
|
||||
final LspProjectContext projectContext,
|
||||
final VfsProjectDocument vfsProjectDocument,
|
||||
final LspDefinitionRequest request) {
|
||||
final var session = buildSession(projectContext, vfsProjectDocument, request.documentPath());
|
||||
return definitionService.definition(session, request);
|
||||
}
|
||||
|
||||
public static SemanticSession buildSession(
|
||||
final LspProjectContext projectContext,
|
||||
final VfsProjectDocument vfsProjectDocument,
|
||||
final Path requestedDocumentPath) {
|
||||
final BuilderPipelineConfig config = new BuilderPipelineConfig(
|
||||
false,
|
||||
projectContext.rootPath().toString(),
|
||||
"core-v1",
|
||||
new OverlaySourceProviderFactoryImpl(vfsProjectDocument, requestedDocumentPath));
|
||||
final BuilderPipelineContext context = BuilderPipelineContext.fromConfig(config);
|
||||
final AnalysisRuntimeSnapshot snapshot = runAnalysisStages(context);
|
||||
return index(snapshot, context, requestedDocumentPath);
|
||||
}
|
||||
|
||||
private static AnalysisRuntimeSnapshot runAnalysisStages(final BuilderPipelineContext context) {
|
||||
final LogAggregator logs = LogAggregator.empty();
|
||||
final List<BuildingIssue> diagnostics = new ArrayList<>();
|
||||
final List<PipelineStage> stages = List.of(
|
||||
new ResolveDepsPipelineStage(),
|
||||
new LoadSourcesPipelineStage());
|
||||
for (final PipelineStage stage : stages) {
|
||||
final BuildingIssueSink stageIssues = stage.run(context, logs);
|
||||
diagnostics.addAll(stageIssues.asCollection());
|
||||
if (stageIssues.hasErrors()) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
final DiagnosticSink frontendDiagnostics = DiagnosticSink.empty();
|
||||
FrontendSpec frontendSpec = FrontendRegistryService.getDefaultFrontendSpec();
|
||||
if (context.resolvedWorkspace != null && context.fileTable != null) {
|
||||
final BuildingIssueSink frontendIssues = runFrontendPhase(context, logs, frontendDiagnostics);
|
||||
diagnostics.addAll(frontendIssues.asCollection());
|
||||
frontendSpec = context.resolvedWorkspace.frontendSpec();
|
||||
}
|
||||
return new AnalysisRuntimeSnapshot(
|
||||
new AnalysisSnapshot(
|
||||
frontendSpec,
|
||||
diagnostics,
|
||||
context.resolvedWorkspace,
|
||||
context.fileTable,
|
||||
context.irBackend),
|
||||
List.copyOf(frontendDiagnostics.asCollection()));
|
||||
}
|
||||
|
||||
private static BuildingIssueSink runFrontendPhase(
|
||||
final BuilderPipelineContext context,
|
||||
final LogAggregator logs,
|
||||
final DiagnosticSink frontendDiagnostics) {
|
||||
final var frontendSpec = context.resolvedWorkspace.frontendSpec();
|
||||
final var service = FrontendRegistryService.getFrontendPhaseService(frontendSpec.getLanguageId());
|
||||
if (service.isEmpty()) {
|
||||
return BuildingIssueSink.empty().report(builder -> builder
|
||||
.error(true)
|
||||
.message("[BUILD]: unable to find a service for frontend phase: " + frontendSpec.getLanguageId()));
|
||||
}
|
||||
final FESurfaceContext feSurfaceContext = new AssetSurfaceContextLoader().load(context.resolvedWorkspace.mainProject().getRootPath());
|
||||
final FrontendPhaseContext frontendPhaseContext = new FrontendPhaseContext(
|
||||
context.resolvedWorkspace.graph().projectTable(),
|
||||
context.fileTable,
|
||||
context.resolvedWorkspace.stack(),
|
||||
context.resolvedWorkspace.stdlib(),
|
||||
HostAdmissionContext.permissiveDefault(),
|
||||
feSurfaceContext);
|
||||
final BuildingIssueSink issues = BuildingIssueSink.empty();
|
||||
context.irBackend = service.get().compile(frontendPhaseContext, frontendDiagnostics, logs, issues);
|
||||
return issues;
|
||||
}
|
||||
|
||||
private static SemanticSession index(
|
||||
final AnalysisRuntimeSnapshot runtimeSnapshot,
|
||||
final BuilderPipelineContext context,
|
||||
final Path requestedDocumentPath) {
|
||||
final AnalysisSnapshot snapshot = runtimeSnapshot.analysisSnapshot();
|
||||
final Map<Path, List<LspDiagnosticDTO>> diagnosticsByDocument = diagnosticsByDocument(
|
||||
snapshot.diagnostics(),
|
||||
snapshot,
|
||||
runtimeSnapshot.frontendDiagnostics());
|
||||
final SemanticIndex semanticIndex = new SemanticIndex();
|
||||
if (snapshot.fileTable() == null) {
|
||||
return new SemanticSession(
|
||||
normalize(requestedDocumentPath),
|
||||
semanticPresentation(snapshot.frontendSpec()),
|
||||
diagnosticsByDocument,
|
||||
Map.of(),
|
||||
Map.of(),
|
||||
Map.of(),
|
||||
Map.of(),
|
||||
List.of(),
|
||||
Map.of(),
|
||||
Map.of());
|
||||
}
|
||||
final Map<FileId, List<PbsAst.TopDecl>> importedSupplementalTopDeclsByFile = importedSupplementalTopDeclsByFile(
|
||||
snapshot.frontendSpec(),
|
||||
context);
|
||||
final Map<Path, List<LspInlineHintDTO>> inlineHintsByDocument = inlineHintsByDocument(
|
||||
snapshot,
|
||||
snapshot.frontendSpec(),
|
||||
context);
|
||||
final List<IndexedDocument> indexedDocuments = new ArrayList<>();
|
||||
for (final FileId fileId : snapshot.fileTable()) {
|
||||
final SourceHandle sourceHandle = snapshot.fileTable().get(fileId);
|
||||
if (!isSourceRelated(snapshot.frontendSpec(), sourceHandle)) {
|
||||
continue;
|
||||
}
|
||||
final String source = sourceHandle.readUtf8().orElse("");
|
||||
final DiagnosticSink diagnostics = DiagnosticSink.empty();
|
||||
final var tokens = PbsLexer.lex(source, fileId, diagnostics);
|
||||
final PbsAst.File ast = PbsParser.parse(tokens, fileId, diagnostics, PbsParser.ParseMode.ORDINARY);
|
||||
final Path documentPath = sourceHandle.getCanonPath();
|
||||
semanticIndex.registerDocument(documentPath, ast, tokens.asList());
|
||||
indexedDocuments.add(new IndexedDocument(
|
||||
fileId,
|
||||
documentPath,
|
||||
importedSupplementalTopDeclsByFile.getOrDefault(fileId, List.of())));
|
||||
}
|
||||
for (final IndexedDocument indexedDocument : indexedDocuments) {
|
||||
semanticIndex.buildHighlights(
|
||||
indexedDocument.documentPath(),
|
||||
indexedDocument.visibleImportedTopDecls());
|
||||
}
|
||||
return new SemanticSession(
|
||||
normalize(requestedDocumentPath),
|
||||
semanticPresentation(snapshot.frontendSpec()),
|
||||
diagnosticsByDocument,
|
||||
semanticIndex.semanticHighlightsByDocument(),
|
||||
inlineHintsByDocument,
|
||||
semanticIndex.documentSymbolsByDocument(),
|
||||
semanticIndex.structuralAnchorsByDocument(),
|
||||
semanticIndex.workspaceSymbols(),
|
||||
semanticIndex.symbolsByName(),
|
||||
semanticIndex.tokensByDocument());
|
||||
}
|
||||
|
||||
private static Map<FileId, List<PbsAst.TopDecl>> importedSupplementalTopDeclsByFile(
|
||||
final FrontendSpec frontendSpec,
|
||||
final BuilderPipelineContext context) {
|
||||
final var surface = semanticReadSurface(frontendSpec, context);
|
||||
final Map<FileId, List<PbsAst.TopDecl>> byFile = new LinkedHashMap<>();
|
||||
for (final var entry : surface.supplementalTopDeclsByFile().entrySet()) {
|
||||
byFile.put(entry.getKey(), entry.getValue().asList());
|
||||
}
|
||||
return Map.copyOf(byFile);
|
||||
}
|
||||
|
||||
private static Map<Path, List<LspInlineHintDTO>> inlineHintsByDocument(
|
||||
final AnalysisSnapshot snapshot,
|
||||
final FrontendSpec frontendSpec,
|
||||
final BuilderPipelineContext context) {
|
||||
if (snapshot.fileTable() == null) {
|
||||
return Map.of();
|
||||
}
|
||||
final var surface = semanticReadSurface(frontendSpec, context);
|
||||
final Map<Path, List<LspInlineHintDTO>> byDocument = new LinkedHashMap<>();
|
||||
for (final var entry : surface.inlineHintsByFile().entrySet()) {
|
||||
final SourceHandle sourceHandle = snapshot.fileTable().get(entry.getKey());
|
||||
final Path documentPath = sourceHandle.getCanonPath().toAbsolutePath().normalize();
|
||||
final var hints = entry.getValue().asList().stream()
|
||||
.map(LspSemanticReadPhase::toInlineHintDTO)
|
||||
.toList();
|
||||
if (!hints.isEmpty()) {
|
||||
byDocument.put(documentPath, hints);
|
||||
}
|
||||
}
|
||||
return Map.copyOf(byDocument);
|
||||
}
|
||||
|
||||
private static PBSFrontendPhaseService.PbsSemanticReadSurface semanticReadSurface(
|
||||
final FrontendSpec frontendSpec,
|
||||
final BuilderPipelineContext context) {
|
||||
if (context.resolvedWorkspace == null || context.fileTable == null || !"pbs".equals(frontendSpec.getLanguageId())) {
|
||||
return new PBSFrontendPhaseService.PbsSemanticReadSurface(Map.of(), Map.of());
|
||||
}
|
||||
final FESurfaceContext feSurfaceContext = new AssetSurfaceContextLoader().load(context.resolvedWorkspace.mainProject().getRootPath());
|
||||
final FrontendPhaseContext frontendPhaseContext = new FrontendPhaseContext(
|
||||
context.resolvedWorkspace.graph().projectTable(),
|
||||
context.fileTable,
|
||||
context.resolvedWorkspace.stack(),
|
||||
context.resolvedWorkspace.stdlib(),
|
||||
HostAdmissionContext.permissiveDefault(),
|
||||
feSurfaceContext);
|
||||
final var diagnostics = DiagnosticSink.empty();
|
||||
final var issues = BuildingIssueSink.empty();
|
||||
return PBSFrontendPhaseService.semanticReadSurface(
|
||||
frontendPhaseContext,
|
||||
diagnostics,
|
||||
issues);
|
||||
}
|
||||
|
||||
private static LspInlineHintDTO toInlineHintDTO(final PbsInlineHintSurface hint) {
|
||||
return new LspInlineHintDTO(
|
||||
new LspRangeDTO(
|
||||
(int) hint.anchorSpan().getStart(),
|
||||
(int) hint.anchorSpan().getEnd()),
|
||||
hint.label(),
|
||||
hint.category());
|
||||
}
|
||||
|
||||
private record IndexedDocument(
|
||||
FileId fileId,
|
||||
Path documentPath,
|
||||
List<PbsAst.TopDecl> visibleImportedTopDecls) {
|
||||
}
|
||||
|
||||
private static boolean isSourceRelated(final FrontendSpec frontendSpec, final SourceHandle sourceHandle) {
|
||||
return frontendSpec.getAllowedExtensions().contains(sourceHandle.getExtension());
|
||||
}
|
||||
|
||||
private static LspSemanticPresentationDTO semanticPresentation(final FrontendSpec frontendSpec) {
|
||||
final FrontendSemanticPresentationSpec presentation = frontendSpec.getSemanticPresentation();
|
||||
return new LspSemanticPresentationDTO(presentation.semanticKeys(), presentation.resources());
|
||||
}
|
||||
|
||||
private static Map<Path, List<LspDiagnosticDTO>> diagnosticsByDocument(
|
||||
final List<BuildingIssue> issues,
|
||||
final AnalysisSnapshot snapshot,
|
||||
final List<Diagnostic> frontendDiagnostics) {
|
||||
final Map<Path, List<LspDiagnosticDTO>> diagnosticsByDocument = new LinkedHashMap<>();
|
||||
diagnosticIssues(issues, snapshot, diagnosticsByDocument);
|
||||
diagnosticFrontend(frontendDiagnostics, snapshot, diagnosticsByDocument);
|
||||
return freezeMapOfLists(diagnosticsByDocument);
|
||||
}
|
||||
|
||||
private static boolean isValidIssueDiagnostic(
|
||||
final AnalysisSnapshot snapshot,
|
||||
final BuildingIssue issue) {
|
||||
if (snapshot.fileTable() == null || issue.getFileId() == null || issue.getFileId() < 0) {
|
||||
return false;
|
||||
}
|
||||
return issue.getFileId() < snapshot.fileTable().size();
|
||||
}
|
||||
|
||||
private static void diagnosticIssues(
|
||||
final List<BuildingIssue> issues,
|
||||
final AnalysisSnapshot snapshot,
|
||||
final Map<Path, List<LspDiagnosticDTO>> diagnosticsByDocument) {
|
||||
for (final var issue : issues) {
|
||||
if (!isValidIssueDiagnostic(snapshot, issue)) {
|
||||
continue;
|
||||
}
|
||||
final SourceHandle sourceHandle = snapshot.fileTable().get(new FileId(issue.getFileId()));
|
||||
final Path documentPath = sourceHandle.getCanonPath().toAbsolutePath().normalize();
|
||||
diagnosticsByDocument
|
||||
.computeIfAbsent(documentPath, ignored -> new ArrayList<>())
|
||||
.add(new LspDiagnosticDTO(
|
||||
documentPath,
|
||||
new LspRangeDTO(
|
||||
safeOffset(issue.getStart()),
|
||||
safeEnd(issue.getStart(), issue.getEnd())),
|
||||
issue.isError()
|
||||
? LspDiagnosticSeverity.ERROR
|
||||
: LspDiagnosticSeverity.WARNING,
|
||||
issue.getPhase(),
|
||||
issue.getCode(),
|
||||
issue.getMessage()));
|
||||
}
|
||||
}
|
||||
|
||||
private static boolean isValidFEDiagnostic(
|
||||
final AnalysisSnapshot snapshot,
|
||||
final Diagnostic diagnostic) {
|
||||
return snapshot.fileTable() != null && !diagnostic.getSpan().getFileId().isNone();
|
||||
}
|
||||
|
||||
private static void diagnosticFrontend(
|
||||
final List<Diagnostic> feDiagnostics,
|
||||
final AnalysisSnapshot snapshot,
|
||||
final Map<Path, List<LspDiagnosticDTO>> diagnosticsByDocument) {
|
||||
for (final var feDiagnostic : feDiagnostics) {
|
||||
if (!isValidFEDiagnostic(snapshot, feDiagnostic)) {
|
||||
continue;
|
||||
}
|
||||
final SourceHandle sourceHandle = snapshot.fileTable().get(feDiagnostic.getSpan().getFileId());
|
||||
final Path documentPath = sourceHandle.getCanonPath().toAbsolutePath().normalize();
|
||||
diagnosticsByDocument
|
||||
.computeIfAbsent(documentPath, ignored -> new ArrayList<>())
|
||||
.add(new LspDiagnosticDTO(
|
||||
documentPath,
|
||||
new LspRangeDTO(
|
||||
(int) feDiagnostic.getSpan().getStart(),
|
||||
(int) feDiagnostic.getSpan().getEnd()),
|
||||
feDiagnostic.getSeverity().isError()
|
||||
? LspDiagnosticSeverity.ERROR
|
||||
: LspDiagnosticSeverity.WARNING,
|
||||
feDiagnostic.getPhase().name(),
|
||||
feDiagnostic.getCode(),
|
||||
feDiagnostic.getMessage()));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,52 +0,0 @@
|
||||
package p.studio.lsp;
|
||||
|
||||
import lombok.experimental.UtilityClass;
|
||||
import p.studio.compiler.pbs.lexer.PbsToken;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Objects;
|
||||
|
||||
@UtilityClass
|
||||
public class LspSemanticUtilities {
|
||||
|
||||
public static PbsToken tokenAt(final List<PbsToken> tokens, final int offset) {
|
||||
for (final PbsToken token : tokens) {
|
||||
if (token.start() <= offset && offset < token.end()) {
|
||||
return token;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static Path normalize(final Path path) {
|
||||
final Path normalized = Objects.requireNonNull(path, "path").toAbsolutePath().normalize();
|
||||
try {
|
||||
return Files.exists(normalized) ? normalized.toRealPath() : normalized;
|
||||
} catch (IOException ignored) {
|
||||
return normalized;
|
||||
}
|
||||
}
|
||||
|
||||
public static <T> Map<Path, List<T>> freezeMapOfLists(final Map<Path, List<T>> mutable) {
|
||||
final Map<Path, List<T>> frozen = new LinkedHashMap<>();
|
||||
for (final var entry : mutable.entrySet()) {
|
||||
frozen.put(entry.getKey(), List.copyOf(entry.getValue()));
|
||||
}
|
||||
return Map.copyOf(frozen);
|
||||
}
|
||||
|
||||
public static int safeOffset(final Integer value) {
|
||||
return value == null ? 0 : Math.max(0, value);
|
||||
}
|
||||
|
||||
public static int safeEnd(final Integer start, final Integer end) {
|
||||
final int safeStart = safeOffset(start);
|
||||
final int safeEnd = safeOffset(end);
|
||||
return Math.max(safeStart, safeEnd);
|
||||
}
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
package p.studio.lsp;
|
||||
|
||||
import p.studio.lsp.messages.LspProjectContext;
|
||||
import p.studio.vfs.VfsProjectDocument;
|
||||
|
||||
import java.util.Objects;
|
||||
|
||||
public final class LspServiceFactoryImpl implements LspServiceFactory {
|
||||
@Override
|
||||
public LspService open(
|
||||
final LspProjectContext projectContext,
|
||||
final VfsProjectDocument vfsProjectDocument) {
|
||||
return new LspServiceImpl(
|
||||
Objects.requireNonNull(projectContext, "projectContext"),
|
||||
Objects.requireNonNull(vfsProjectDocument, "vfsProjectDocument"));
|
||||
}
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
package p.studio.lsp;
|
||||
|
||||
import p.studio.lsp.dtos.LspSessionStateDTO;
|
||||
import p.studio.lsp.messages.*;
|
||||
import p.studio.vfs.VfsProjectDocument;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Objects;
|
||||
|
||||
public final class LspServiceImpl implements LspService {
|
||||
private final LspProjectContext projectContext;
|
||||
private final VfsProjectDocument vfsProjectDocument;
|
||||
|
||||
private final LspSemanticReadPhase semanticReadPhase;
|
||||
|
||||
public LspServiceImpl(
|
||||
final LspProjectContext projectContext,
|
||||
final VfsProjectDocument vfsProjectDocument) {
|
||||
this.projectContext = Objects.requireNonNull(projectContext, "projectContext");
|
||||
this.vfsProjectDocument = Objects.requireNonNull(vfsProjectDocument, "vfsProjectDocument");
|
||||
this.semanticReadPhase = new LspSemanticReadPhase();
|
||||
}
|
||||
|
||||
@Override
|
||||
public LspProjectContext projectContext() {
|
||||
return projectContext;
|
||||
}
|
||||
|
||||
@Override
|
||||
public VfsProjectDocument projectDocumentVfs() {
|
||||
return vfsProjectDocument;
|
||||
}
|
||||
|
||||
@Override
|
||||
public LspSessionStateDTO snapshot() {
|
||||
return new LspSessionStateDTO(
|
||||
true,
|
||||
List.of("diagnostics", "symbols", "definition", "highlight"));
|
||||
}
|
||||
|
||||
@Override
|
||||
public LspAnalyzeDocumentResult analyzeDocument(final LspAnalyzeDocumentRequest request) {
|
||||
return semanticReadPhase.analyze(projectContext, vfsProjectDocument, request);
|
||||
}
|
||||
|
||||
@Override
|
||||
public LspDefinitionResult definition(final LspDefinitionRequest request) {
|
||||
return semanticReadPhase.definition(projectContext, vfsProjectDocument, request);
|
||||
}
|
||||
}
|
||||
-51
@@ -1,51 +0,0 @@
|
||||
package p.studio.lsp;
|
||||
|
||||
import p.studio.compiler.utilities.SourceProvider;
|
||||
import p.studio.compiler.utilities.SourceProviderFactory;
|
||||
import p.studio.vfs.VfsDocumentOpenResult;
|
||||
import p.studio.vfs.VfsProjectDocument;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.util.Objects;
|
||||
|
||||
final class OverlaySourceProviderFactoryImpl implements SourceProviderFactory {
|
||||
private final VfsProjectDocument vfsProjectDocument;
|
||||
private final Path openedDocumentPath;
|
||||
|
||||
OverlaySourceProviderFactoryImpl(
|
||||
final VfsProjectDocument vfsProjectDocument,
|
||||
final Path openedDocumentPath) {
|
||||
this.vfsProjectDocument = Objects.requireNonNull(vfsProjectDocument, "vfsProjectDocument");
|
||||
this.openedDocumentPath = openedDocumentPath == null
|
||||
? null
|
||||
: normalize(openedDocumentPath);
|
||||
}
|
||||
|
||||
@Override
|
||||
public SourceProvider create(final Path path) {
|
||||
final Path normalizedPath = normalize(path);
|
||||
return () -> read(normalizedPath);
|
||||
}
|
||||
|
||||
private byte[] read(final Path path) throws IOException {
|
||||
if (openedDocumentPath != null && openedDocumentPath.equals(path)) {
|
||||
final VfsDocumentOpenResult result = vfsProjectDocument.openDocument(path);
|
||||
if (result instanceof VfsDocumentOpenResult.VfsTextDocument textDocument) {
|
||||
return textDocument.content().getBytes(StandardCharsets.UTF_8);
|
||||
}
|
||||
}
|
||||
return Files.readAllBytes(path);
|
||||
}
|
||||
|
||||
private Path normalize(final Path path) {
|
||||
final Path normalized = path.toAbsolutePath().normalize();
|
||||
try {
|
||||
return Files.exists(normalized) ? normalized.toRealPath() : normalized;
|
||||
} catch (IOException ignored) {
|
||||
return normalized;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
package p.studio.lsp.messages;
|
||||
|
||||
import p.studio.compiler.pbs.lexer.PbsToken;
|
||||
import p.studio.lsp.dtos.LspDiagnosticDTO;
|
||||
import p.studio.lsp.dtos.LspHighlightSpanDTO;
|
||||
import p.studio.lsp.dtos.LspInlineHintDTO;
|
||||
import p.studio.lsp.dtos.LspSemanticPresentationDTO;
|
||||
import p.studio.lsp.dtos.LspStructuralAnchorDTO;
|
||||
import p.studio.lsp.dtos.LspSymbolDTO;
|
||||
|
||||
import java.nio.file.Path;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
public record SemanticSession(
|
||||
Path requestedDocumentPath,
|
||||
LspSemanticPresentationDTO semanticPresentation,
|
||||
Map<Path, List<LspDiagnosticDTO>> diagnosticsByDocument,
|
||||
Map<Path, List<LspHighlightSpanDTO>> semanticHighlightsByDocument,
|
||||
Map<Path, List<LspInlineHintDTO>> inlineHintsByDocument,
|
||||
Map<Path, List<LspSymbolDTO>> documentSymbolsByDocument,
|
||||
Map<Path, List<LspStructuralAnchorDTO>> structuralAnchorsByDocument,
|
||||
List<LspSymbolDTO> workspaceSymbols,
|
||||
Map<String, List<LspSymbolDTO>> symbolsByName,
|
||||
Map<Path, List<PbsToken>> tokensByDocument) {
|
||||
}
|
||||
-11
@@ -1,11 +0,0 @@
|
||||
package p.studio.lsp.models;
|
||||
|
||||
import p.studio.compiler.models.AnalysisSnapshot;
|
||||
import p.studio.compiler.source.diagnostics.Diagnostic;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public record AnalysisRuntimeSnapshot(
|
||||
AnalysisSnapshot analysisSnapshot,
|
||||
List<Diagnostic> frontendDiagnostics) {
|
||||
}
|
||||
@@ -1,635 +0,0 @@
|
||||
package p.studio.lsp.models;
|
||||
|
||||
import p.studio.compiler.pbs.PbsSemanticKind;
|
||||
import p.studio.compiler.pbs.ast.PbsAst;
|
||||
import p.studio.compiler.pbs.lexer.PbsToken;
|
||||
import p.studio.compiler.pbs.lexer.PbsTokenKind;
|
||||
import p.studio.compiler.source.Span;
|
||||
import p.studio.lsp.dtos.LspHighlightSpanDTO;
|
||||
import p.studio.lsp.dtos.LspRangeDTO;
|
||||
import p.studio.lsp.dtos.LspStructuralAnchorDTO;
|
||||
import p.studio.lsp.dtos.LspSymbolDTO;
|
||||
import p.studio.lsp.messages.LspSymbolKind;
|
||||
|
||||
import java.nio.file.Path;
|
||||
import java.util.ArrayList;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Objects;
|
||||
|
||||
import static p.studio.lsp.LspSemanticUtilities.normalize;
|
||||
|
||||
public final class SemanticIndex {
|
||||
private final Map<Path, List<LspHighlightSpanDTO>> semanticHighlightsByDocument = new LinkedHashMap<>();
|
||||
private final Map<Path, List<LspSymbolDTO>> documentSymbolsByDocument = new LinkedHashMap<>();
|
||||
private final Map<Path, List<LspStructuralAnchorDTO>> structuralAnchorsByDocument = new LinkedHashMap<>();
|
||||
private final List<LspSymbolDTO> workspaceSymbols = new ArrayList<>();
|
||||
private final Map<String, List<LspSymbolDTO>> symbolsByName = new LinkedHashMap<>();
|
||||
private final Map<Path, List<PbsToken>> tokensByDocument = new LinkedHashMap<>();
|
||||
|
||||
public void index(
|
||||
final Path documentPath,
|
||||
final PbsAst.File ast,
|
||||
final List<PbsToken> tokens) {
|
||||
index(documentPath, ast, tokens, List.of());
|
||||
}
|
||||
|
||||
public void index(
|
||||
final Path documentPath,
|
||||
final PbsAst.File ast,
|
||||
final List<PbsToken> tokens,
|
||||
final List<PbsAst.TopDecl> visibleImportedTopDecls) {
|
||||
registerDocument(documentPath, ast, tokens);
|
||||
buildHighlights(documentPath, visibleImportedTopDecls);
|
||||
}
|
||||
|
||||
public void registerDocument(
|
||||
final Path documentPath,
|
||||
final PbsAst.File ast,
|
||||
final List<PbsToken> tokens) {
|
||||
final Path normalizedDocumentPath = normalize(documentPath);
|
||||
tokensByDocument.put(normalizedDocumentPath, List.copyOf(tokens));
|
||||
final List<LspSymbolDTO> documentSymbols = new ArrayList<>();
|
||||
for (final PbsAst.TopDecl topDecl : ast.topDecls()) {
|
||||
final LspSymbolDTO symbol = symbolForTopDecl(normalizedDocumentPath, topDecl);
|
||||
if (symbol == null) {
|
||||
continue;
|
||||
}
|
||||
documentSymbols.add(symbol);
|
||||
workspaceSymbols.add(symbol);
|
||||
symbolsByName.computeIfAbsent(symbol.name(), ignored -> new ArrayList<>()).add(symbol);
|
||||
for (final LspSymbolDTO child : symbol.children()) {
|
||||
symbolsByName.computeIfAbsent(child.name(), ignored -> new ArrayList<>()).add(child);
|
||||
}
|
||||
}
|
||||
documentSymbolsByDocument.put(normalizedDocumentPath, List.copyOf(documentSymbols));
|
||||
structuralAnchorsByDocument.put(
|
||||
normalizedDocumentPath,
|
||||
structuralAnchors(documentSymbols, tokens));
|
||||
}
|
||||
|
||||
public void buildHighlights(
|
||||
final Path documentPath,
|
||||
final List<PbsAst.TopDecl> visibleImportedTopDecls) {
|
||||
final Path normalizedDocumentPath = normalize(documentPath);
|
||||
final List<PbsToken> tokens = tokensByDocument.getOrDefault(normalizedDocumentPath, List.of());
|
||||
final Map<String, LspSymbolKind> visibleKindsByName = new LinkedHashMap<>();
|
||||
for (final var entry : symbolsByName.entrySet()) {
|
||||
if (entry.getValue().isEmpty()) {
|
||||
continue;
|
||||
}
|
||||
visibleKindsByName.putIfAbsent(entry.getKey(), entry.getValue().getFirst().kind());
|
||||
}
|
||||
for (final LspSymbolDTO symbol : documentSymbolsByDocument.getOrDefault(normalizedDocumentPath, List.of())) {
|
||||
visibleKindsByName.putIfAbsent(symbol.name(), symbol.kind());
|
||||
for (final LspSymbolDTO child : symbol.children()) {
|
||||
visibleKindsByName.putIfAbsent(child.name(), child.kind());
|
||||
}
|
||||
}
|
||||
for (final PbsAst.TopDecl topDecl : visibleImportedTopDecls) {
|
||||
final LspSymbolKind visibleKind = symbolKindForTopDecl(topDecl);
|
||||
final String visibleName = topDeclName(topDecl);
|
||||
if (visibleKind == null || visibleName == null || visibleName.isBlank()) {
|
||||
continue;
|
||||
}
|
||||
visibleKindsByName.putIfAbsent(visibleName, visibleKind);
|
||||
}
|
||||
semanticHighlightsByDocument.put(
|
||||
normalizedDocumentPath,
|
||||
buildSemanticHighlights(tokens, visibleKindsByName));
|
||||
}
|
||||
|
||||
private List<LspHighlightSpanDTO> buildSemanticHighlights(
|
||||
final List<PbsToken> tokens,
|
||||
final Map<String, LspSymbolKind> visibleKindsByName) {
|
||||
final List<LspHighlightSpanDTO> highlights = new ArrayList<>();
|
||||
for (int index = 0; index < tokens.size(); index++) {
|
||||
final PbsToken token = tokens.get(index);
|
||||
if (token.kind() == PbsTokenKind.EOF) {
|
||||
continue;
|
||||
}
|
||||
final String semanticKey = semanticKey(tokens, index, visibleKindsByName);
|
||||
if (semanticKey == null || semanticKey.isBlank()) {
|
||||
continue;
|
||||
}
|
||||
highlights.add(new LspHighlightSpanDTO(
|
||||
new LspRangeDTO(token.start(), token.end()),
|
||||
semanticKey));
|
||||
}
|
||||
return List.copyOf(highlights);
|
||||
}
|
||||
|
||||
private String semanticKey(
|
||||
final List<PbsToken> tokens,
|
||||
final int tokenIndex,
|
||||
final Map<String, LspSymbolKind> visibleKindsByName) {
|
||||
final PbsToken token = tokens.get(tokenIndex);
|
||||
if (isLifecycleAttributeToken(tokens, tokenIndex)) {
|
||||
return PbsSemanticKind.LIFECYCLE.semanticKey();
|
||||
}
|
||||
final PbsSemanticKind semanticKind = token.kind() == p.studio.compiler.pbs.lexer.PbsTokenKind.IDENTIFIER
|
||||
? semanticKindForIdentifier(token.lexeme(), visibleKindsByName)
|
||||
: PbsSemanticKind.forToken(token);
|
||||
return semanticKind == null ? null : semanticKind.semanticKey();
|
||||
}
|
||||
|
||||
private boolean isLifecycleAttributeToken(final List<PbsToken> tokens, final int tokenIndex) {
|
||||
if (tokenIndex < 0 || tokenIndex >= tokens.size()) {
|
||||
return false;
|
||||
}
|
||||
final PbsToken token = tokens.get(tokenIndex);
|
||||
return switch (token.kind()) {
|
||||
case LEFT_BRACKET -> hasLifecycleAttributeWindow(tokens, tokenIndex, tokenIndex + 1, tokenIndex + 2);
|
||||
case IDENTIFIER -> hasLifecycleAttributeWindow(tokens, tokenIndex - 1, tokenIndex, tokenIndex + 1);
|
||||
case RIGHT_BRACKET -> hasLifecycleAttributeWindow(tokens, tokenIndex - 2, tokenIndex - 1, tokenIndex);
|
||||
default -> false;
|
||||
};
|
||||
}
|
||||
|
||||
private boolean hasLifecycleAttributeWindow(
|
||||
final List<PbsToken> tokens,
|
||||
final int leftBracketIndex,
|
||||
final int identifierIndex,
|
||||
final int rightBracketIndex) {
|
||||
if (leftBracketIndex < 0 || rightBracketIndex >= tokens.size()) {
|
||||
return false;
|
||||
}
|
||||
return tokens.get(leftBracketIndex).kind() == PbsTokenKind.LEFT_BRACKET
|
||||
&& tokens.get(identifierIndex).kind() == PbsTokenKind.IDENTIFIER
|
||||
&& isLifecycleAttributeName(tokens.get(identifierIndex).lexeme())
|
||||
&& tokens.get(rightBracketIndex).kind() == PbsTokenKind.RIGHT_BRACKET;
|
||||
}
|
||||
|
||||
private boolean isLifecycleAttributeName(final String lexeme) {
|
||||
return "Init".equals(lexeme) || "Frame".equals(lexeme);
|
||||
}
|
||||
|
||||
private PbsSemanticKind semanticKindForIdentifier(
|
||||
final String lexeme,
|
||||
final Map<String, LspSymbolKind> visibleKindsByName) {
|
||||
final LspSymbolKind kind = visibleKindsByName.get(lexeme);
|
||||
if (kind == null) {
|
||||
return PbsSemanticKind.IDENTIFIER;
|
||||
}
|
||||
return switch (kind) {
|
||||
case FUNCTION -> PbsSemanticKind.FUNCTION;
|
||||
case METHOD -> PbsSemanticKind.METHOD;
|
||||
case CONSTRUCTOR -> PbsSemanticKind.CONSTRUCTOR;
|
||||
case STRUCT -> PbsSemanticKind.STRUCT;
|
||||
case CONTRACT -> PbsSemanticKind.CONTRACT;
|
||||
case HOST -> PbsSemanticKind.HOST;
|
||||
case BUILTIN_TYPE -> PbsSemanticKind.BUILTIN_TYPE;
|
||||
case SERVICE -> PbsSemanticKind.SERVICE;
|
||||
case ERROR -> PbsSemanticKind.ERROR;
|
||||
case ENUM -> PbsSemanticKind.ENUM;
|
||||
case CALLBACK -> PbsSemanticKind.CALLBACK;
|
||||
case GLOBAL -> PbsSemanticKind.GLOBAL;
|
||||
case CONST -> PbsSemanticKind.CONST;
|
||||
case IMPLEMENTS -> PbsSemanticKind.IMPLEMENTS;
|
||||
default -> PbsSemanticKind.IDENTIFIER;
|
||||
};
|
||||
}
|
||||
|
||||
private String topDeclName(final PbsAst.TopDecl topDecl) {
|
||||
if (topDecl instanceof PbsAst.FunctionDecl functionDecl) {
|
||||
return functionDecl.name();
|
||||
}
|
||||
if (topDecl instanceof PbsAst.StructDecl structDecl) {
|
||||
return structDecl.name();
|
||||
}
|
||||
if (topDecl instanceof PbsAst.ContractDecl contractDecl) {
|
||||
return contractDecl.name();
|
||||
}
|
||||
if (topDecl instanceof PbsAst.HostDecl hostDecl) {
|
||||
return hostDecl.name();
|
||||
}
|
||||
if (topDecl instanceof PbsAst.BuiltinTypeDecl builtinTypeDecl) {
|
||||
return builtinTypeDecl.name();
|
||||
}
|
||||
if (topDecl instanceof PbsAst.ServiceDecl serviceDecl) {
|
||||
return serviceDecl.name();
|
||||
}
|
||||
if (topDecl instanceof PbsAst.ErrorDecl errorDecl) {
|
||||
return errorDecl.name();
|
||||
}
|
||||
if (topDecl instanceof PbsAst.EnumDecl enumDecl) {
|
||||
return enumDecl.name();
|
||||
}
|
||||
if (topDecl instanceof PbsAst.CallbackDecl callbackDecl) {
|
||||
return callbackDecl.name();
|
||||
}
|
||||
if (topDecl instanceof PbsAst.GlobalDecl globalDecl) {
|
||||
return globalDecl.name();
|
||||
}
|
||||
if (topDecl instanceof PbsAst.ConstDecl constDecl) {
|
||||
return constDecl.name();
|
||||
}
|
||||
if (topDecl instanceof PbsAst.ImplementsDecl implementsDecl) {
|
||||
return implementsDecl.binderName();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private LspSymbolKind symbolKindForTopDecl(final PbsAst.TopDecl topDecl) {
|
||||
if (topDecl instanceof PbsAst.FunctionDecl) {
|
||||
return LspSymbolKind.FUNCTION;
|
||||
}
|
||||
if (topDecl instanceof PbsAst.StructDecl) {
|
||||
return LspSymbolKind.STRUCT;
|
||||
}
|
||||
if (topDecl instanceof PbsAst.ContractDecl) {
|
||||
return LspSymbolKind.CONTRACT;
|
||||
}
|
||||
if (topDecl instanceof PbsAst.HostDecl) {
|
||||
return LspSymbolKind.HOST;
|
||||
}
|
||||
if (topDecl instanceof PbsAst.BuiltinTypeDecl) {
|
||||
return LspSymbolKind.BUILTIN_TYPE;
|
||||
}
|
||||
if (topDecl instanceof PbsAst.ServiceDecl) {
|
||||
return LspSymbolKind.SERVICE;
|
||||
}
|
||||
if (topDecl instanceof PbsAst.ErrorDecl) {
|
||||
return LspSymbolKind.ERROR;
|
||||
}
|
||||
if (topDecl instanceof PbsAst.EnumDecl) {
|
||||
return LspSymbolKind.ENUM;
|
||||
}
|
||||
if (topDecl instanceof PbsAst.CallbackDecl) {
|
||||
return LspSymbolKind.CALLBACK;
|
||||
}
|
||||
if (topDecl instanceof PbsAst.GlobalDecl) {
|
||||
return LspSymbolKind.GLOBAL;
|
||||
}
|
||||
if (topDecl instanceof PbsAst.ConstDecl) {
|
||||
return LspSymbolKind.CONST;
|
||||
}
|
||||
if (topDecl instanceof PbsAst.ImplementsDecl) {
|
||||
return LspSymbolKind.IMPLEMENTS;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private LspSymbolDTO symbolForTopDecl(
|
||||
final Path documentPath,
|
||||
final PbsAst.TopDecl topDecl) {
|
||||
if (topDecl instanceof PbsAst.FunctionDecl functionDecl) {
|
||||
return symbol(
|
||||
documentPath,
|
||||
functionDecl.name(),
|
||||
LspSymbolKind.FUNCTION,
|
||||
functionDecl.span(),
|
||||
localSymbolsInBlock(documentPath, functionDecl.body()));
|
||||
}
|
||||
if (topDecl instanceof PbsAst.StructDecl structDecl) {
|
||||
return symbol(documentPath, structDecl.name(), LspSymbolKind.STRUCT, structDecl.span(), structChildren(documentPath, structDecl));
|
||||
}
|
||||
if (topDecl instanceof PbsAst.ContractDecl(
|
||||
String name, p.studio.utilities.structures.ReadOnlyList<PbsAst.FunctionSignature> signatures, Span span
|
||||
)) {
|
||||
return symbol(documentPath, name, LspSymbolKind.CONTRACT, span, signatureChildren(documentPath, signatures.asList()));
|
||||
}
|
||||
if (topDecl instanceof PbsAst.HostDecl(
|
||||
String name, p.studio.utilities.structures.ReadOnlyList<PbsAst.FunctionSignature> signatures, Span span
|
||||
)) {
|
||||
return symbol(documentPath, name, LspSymbolKind.HOST, span, signatureChildren(documentPath, signatures.asList()));
|
||||
}
|
||||
if (topDecl instanceof PbsAst.BuiltinTypeDecl builtinTypeDecl) {
|
||||
return symbol(documentPath, builtinTypeDecl.name(), LspSymbolKind.BUILTIN_TYPE, builtinTypeDecl.span(), signatureChildren(documentPath, builtinTypeDecl.signatures().asList()));
|
||||
}
|
||||
if (topDecl instanceof PbsAst.ServiceDecl(
|
||||
String name, p.studio.utilities.structures.ReadOnlyList<PbsAst.FunctionDecl> methods, Span span
|
||||
)) {
|
||||
return symbol(documentPath, name, LspSymbolKind.SERVICE, span, functionChildren(documentPath, methods.asList()));
|
||||
}
|
||||
if (topDecl instanceof PbsAst.ErrorDecl errorDecl) {
|
||||
return symbol(documentPath, errorDecl.name(), LspSymbolKind.ERROR, errorDecl.span(), List.of());
|
||||
}
|
||||
if (topDecl instanceof PbsAst.EnumDecl enumDecl) {
|
||||
return symbol(documentPath, enumDecl.name(), LspSymbolKind.ENUM, enumDecl.span(), List.of());
|
||||
}
|
||||
if (topDecl instanceof PbsAst.CallbackDecl callbackDecl) {
|
||||
return symbol(documentPath, callbackDecl.name(), LspSymbolKind.CALLBACK, callbackDecl.span(), List.of());
|
||||
}
|
||||
if (topDecl instanceof PbsAst.GlobalDecl globalDecl) {
|
||||
return symbol(documentPath, globalDecl.name(), LspSymbolKind.GLOBAL, globalDecl.span(), List.of());
|
||||
}
|
||||
if (topDecl instanceof PbsAst.ConstDecl constDecl) {
|
||||
return symbol(documentPath, constDecl.name(), LspSymbolKind.CONST, constDecl.span(), List.of());
|
||||
}
|
||||
if (topDecl instanceof PbsAst.ImplementsDecl implementsDecl) {
|
||||
return symbol(documentPath, implementsDecl.binderName(), LspSymbolKind.IMPLEMENTS, implementsDecl.span(), functionChildren(documentPath, implementsDecl.methods().asList()));
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private List<LspSymbolDTO> structChildren(
|
||||
final Path documentPath,
|
||||
final PbsAst.StructDecl structDecl) {
|
||||
final List<LspSymbolDTO> children = new ArrayList<>(functionChildren(documentPath, structDecl.methods().asList()));
|
||||
for (final PbsAst.CtorDecl ctorDecl : structDecl.ctors()) {
|
||||
children.add(symbol(
|
||||
documentPath,
|
||||
ctorDecl.name(),
|
||||
LspSymbolKind.CONSTRUCTOR,
|
||||
ctorDecl.span(),
|
||||
localSymbolsInBlock(documentPath, ctorDecl.body())));
|
||||
}
|
||||
return List.copyOf(children);
|
||||
}
|
||||
|
||||
private List<LspSymbolDTO> functionChildren(
|
||||
final Path documentPath,
|
||||
final List<PbsAst.FunctionDecl> functions) {
|
||||
final List<LspSymbolDTO> children = new ArrayList<>();
|
||||
for (final PbsAst.FunctionDecl functionDecl : functions) {
|
||||
children.add(symbol(
|
||||
documentPath,
|
||||
functionDecl.name(),
|
||||
LspSymbolKind.METHOD,
|
||||
functionDecl.span(),
|
||||
localSymbolsInBlock(documentPath, functionDecl.body())));
|
||||
}
|
||||
return List.copyOf(children);
|
||||
}
|
||||
|
||||
private List<LspSymbolDTO> localSymbolsInBlock(
|
||||
final Path documentPath,
|
||||
final PbsAst.Block block) {
|
||||
final List<LspSymbolDTO> children = new ArrayList<>();
|
||||
for (final PbsAst.Statement statement : block.statements().asList()) {
|
||||
children.addAll(localSymbolsInStatement(documentPath, statement));
|
||||
}
|
||||
if (block.tailExpression() != null) {
|
||||
children.addAll(localSymbolsInExpression(documentPath, block.tailExpression()));
|
||||
}
|
||||
return List.copyOf(children);
|
||||
}
|
||||
|
||||
private List<LspSymbolDTO> localSymbolsInStatement(
|
||||
final Path documentPath,
|
||||
final PbsAst.Statement statement) {
|
||||
return switch (statement) {
|
||||
case PbsAst.LetStatement letStatement -> localSymbolsInExpression(documentPath, letStatement.initializer());
|
||||
case PbsAst.AssignStatement assignStatement -> localSymbolsInExpression(documentPath, assignStatement.value());
|
||||
case PbsAst.ReturnStatement returnStatement -> localSymbolsInNullableExpression(documentPath, returnStatement.value());
|
||||
case PbsAst.IfStatement ifStatement -> List.of(symbol(
|
||||
documentPath,
|
||||
"if",
|
||||
LspSymbolKind.IF,
|
||||
ifStatement.span(),
|
||||
children(
|
||||
localSymbolsInBlock(documentPath, ifStatement.thenBlock()),
|
||||
ifStatement.elseIf() == null ? List.of() : localSymbolsInStatement(documentPath, ifStatement.elseIf()),
|
||||
ifStatement.elseBlock() == null ? List.of() : localSymbolsInBlock(documentPath, ifStatement.elseBlock()))));
|
||||
case PbsAst.ForStatement forStatement -> List.of(symbol(
|
||||
documentPath,
|
||||
"for " + forStatement.iteratorName(),
|
||||
LspSymbolKind.FOR,
|
||||
forStatement.span(),
|
||||
localSymbolsInBlock(documentPath, forStatement.body())));
|
||||
case PbsAst.WhileStatement whileStatement -> List.of(symbol(
|
||||
documentPath,
|
||||
"while",
|
||||
LspSymbolKind.WHILE,
|
||||
whileStatement.span(),
|
||||
localSymbolsInBlock(documentPath, whileStatement.body())));
|
||||
case PbsAst.ExpressionStatement expressionStatement -> localSymbolsInExpression(documentPath, expressionStatement.expression());
|
||||
case PbsAst.BreakStatement ignored -> List.of();
|
||||
case PbsAst.ContinueStatement ignored -> List.of();
|
||||
};
|
||||
}
|
||||
|
||||
private List<LspSymbolDTO> localSymbolsInExpression(
|
||||
final Path documentPath,
|
||||
final PbsAst.Expression expression) {
|
||||
return switch (expression) {
|
||||
case PbsAst.IfExpr ifExpr -> List.of(symbol(
|
||||
documentPath,
|
||||
"if",
|
||||
LspSymbolKind.IF,
|
||||
ifExpr.span(),
|
||||
children(
|
||||
localSymbolsInBlock(documentPath, ifExpr.thenBlock()),
|
||||
localSymbolsInExpression(documentPath, ifExpr.elseExpression()))));
|
||||
case PbsAst.SwitchExpr switchExpr -> List.of(symbol(
|
||||
documentPath,
|
||||
"switch",
|
||||
LspSymbolKind.SWITCH,
|
||||
switchExpr.span(),
|
||||
childrenFromSwitchArms(documentPath, switchExpr.arms().asList())));
|
||||
case PbsAst.HandleExpr handleExpr -> List.of(symbol(
|
||||
documentPath,
|
||||
"handle",
|
||||
LspSymbolKind.HANDLE,
|
||||
handleExpr.span(),
|
||||
childrenFromHandleArms(documentPath, handleExpr.arms().asList())));
|
||||
case PbsAst.BlockExpr blockExpr -> localSymbolsInBlock(documentPath, blockExpr.block());
|
||||
case PbsAst.ElseExpr elseExpr -> children(
|
||||
localSymbolsInExpression(documentPath, elseExpr.optionalExpression()),
|
||||
localSymbolsInExpression(documentPath, elseExpr.fallbackExpression()));
|
||||
case PbsAst.UnaryExpr unaryExpr -> localSymbolsInExpression(documentPath, unaryExpr.expression());
|
||||
case PbsAst.BinaryExpr binaryExpr -> children(
|
||||
localSymbolsInExpression(documentPath, binaryExpr.left()),
|
||||
localSymbolsInExpression(documentPath, binaryExpr.right()));
|
||||
case PbsAst.ApplyExpr applyExpr -> children(
|
||||
localSymbolsInExpression(documentPath, applyExpr.callee()),
|
||||
localSymbolsInExpression(documentPath, applyExpr.argument()));
|
||||
case PbsAst.AsExpr asExpr -> localSymbolsInExpression(documentPath, asExpr.expression());
|
||||
case PbsAst.CallExpr callExpr -> {
|
||||
final List<List<LspSymbolDTO>> nested = new ArrayList<>();
|
||||
nested.add(localSymbolsInExpression(documentPath, callExpr.callee()));
|
||||
for (final PbsAst.Expression argument : callExpr.arguments().asList()) {
|
||||
nested.add(localSymbolsInExpression(documentPath, argument));
|
||||
}
|
||||
yield children(nested.toArray(List[]::new));
|
||||
}
|
||||
case PbsAst.MemberExpr memberExpr -> localSymbolsInExpression(documentPath, memberExpr.receiver());
|
||||
case PbsAst.PropagateExpr propagateExpr -> localSymbolsInExpression(documentPath, propagateExpr.expression());
|
||||
case PbsAst.GroupExpr groupExpr -> localSymbolsInExpression(documentPath, groupExpr.expression());
|
||||
case PbsAst.NewExpr newExpr -> {
|
||||
final List<List<LspSymbolDTO>> nested = new ArrayList<>();
|
||||
for (final PbsAst.Expression argument : newExpr.arguments().asList()) {
|
||||
nested.add(localSymbolsInExpression(documentPath, argument));
|
||||
}
|
||||
yield children(nested.toArray(List[]::new));
|
||||
}
|
||||
case PbsAst.BindExpr bindExpr -> localSymbolsInExpression(documentPath, bindExpr.contextExpression());
|
||||
case PbsAst.SomeExpr someExpr -> localSymbolsInExpression(documentPath, someExpr.value());
|
||||
case PbsAst.OkExpr okExpr -> localSymbolsInExpression(documentPath, okExpr.value());
|
||||
case PbsAst.TupleExpr tupleExpr -> {
|
||||
final List<List<LspSymbolDTO>> nested = new ArrayList<>();
|
||||
for (final PbsAst.TupleItem item : tupleExpr.items().asList()) {
|
||||
nested.add(localSymbolsInExpression(documentPath, item.expression()));
|
||||
}
|
||||
yield children(nested.toArray(List[]::new));
|
||||
}
|
||||
case PbsAst.IdentifierExpr ignored -> List.of();
|
||||
case PbsAst.IntLiteralExpr ignored -> List.of();
|
||||
case PbsAst.FloatLiteralExpr ignored -> List.of();
|
||||
case PbsAst.BoundedLiteralExpr ignored -> List.of();
|
||||
case PbsAst.StringLiteralExpr ignored -> List.of();
|
||||
case PbsAst.BoolLiteralExpr ignored -> List.of();
|
||||
case PbsAst.ThisExpr ignored -> List.of();
|
||||
case PbsAst.NoneExpr ignored -> List.of();
|
||||
case PbsAst.ErrExpr ignored -> List.of();
|
||||
case PbsAst.UnitExpr ignored -> List.of();
|
||||
};
|
||||
}
|
||||
|
||||
private List<LspSymbolDTO> childrenFromSwitchArms(
|
||||
final Path documentPath,
|
||||
final List<PbsAst.SwitchArm> arms) {
|
||||
final List<LspSymbolDTO> children = new ArrayList<>();
|
||||
for (final PbsAst.SwitchArm arm : arms) {
|
||||
children.addAll(localSymbolsInBlock(documentPath, arm.block()));
|
||||
}
|
||||
return List.copyOf(children);
|
||||
}
|
||||
|
||||
private List<LspSymbolDTO> childrenFromHandleArms(
|
||||
final Path documentPath,
|
||||
final List<PbsAst.HandleArm> arms) {
|
||||
final List<LspSymbolDTO> children = new ArrayList<>();
|
||||
for (final PbsAst.HandleArm arm : arms) {
|
||||
children.addAll(localSymbolsInBlock(documentPath, arm.block()));
|
||||
}
|
||||
return List.copyOf(children);
|
||||
}
|
||||
|
||||
private List<LspSymbolDTO> localSymbolsInNullableExpression(
|
||||
final Path documentPath,
|
||||
final PbsAst.Expression expression) {
|
||||
return expression == null ? List.of() : localSymbolsInExpression(documentPath, expression);
|
||||
}
|
||||
|
||||
@SafeVarargs
|
||||
private static List<LspSymbolDTO> children(final List<LspSymbolDTO>... parts) {
|
||||
final List<LspSymbolDTO> children = new ArrayList<>();
|
||||
for (final List<LspSymbolDTO> part : parts) {
|
||||
if (part == null || part.isEmpty()) {
|
||||
continue;
|
||||
}
|
||||
children.addAll(part);
|
||||
}
|
||||
return List.copyOf(children);
|
||||
}
|
||||
|
||||
private List<LspSymbolDTO> signatureChildren(
|
||||
final Path documentPath,
|
||||
final List<PbsAst.FunctionSignature> signatures) {
|
||||
final List<LspSymbolDTO> children = new ArrayList<>();
|
||||
for (final PbsAst.FunctionSignature signature : signatures) {
|
||||
children.add(symbol(documentPath, signature.name(), LspSymbolKind.METHOD, signature.span(), List.of()));
|
||||
}
|
||||
return List.copyOf(children);
|
||||
}
|
||||
|
||||
private LspSymbolDTO symbol(
|
||||
final Path documentPath,
|
||||
final String name,
|
||||
final LspSymbolKind kind,
|
||||
final Span span,
|
||||
final List<LspSymbolDTO> children) {
|
||||
return new LspSymbolDTO(
|
||||
Objects.requireNonNullElse(name, kind.name().toLowerCase()),
|
||||
kind,
|
||||
documentPath,
|
||||
new LspRangeDTO((int) span.getStart(), (int) span.getEnd()),
|
||||
children);
|
||||
}
|
||||
|
||||
private List<LspStructuralAnchorDTO> structuralAnchors(
|
||||
final List<LspSymbolDTO> documentSymbols,
|
||||
final List<PbsToken> tokens) {
|
||||
final List<LspStructuralAnchorDTO> anchors = new ArrayList<>();
|
||||
for (final LspSymbolDTO symbol : documentSymbols) {
|
||||
final LspStructuralAnchorDTO anchor = structuralAnchor(symbol, tokens);
|
||||
if (anchor != null) {
|
||||
anchors.add(anchor);
|
||||
}
|
||||
}
|
||||
return List.copyOf(anchors);
|
||||
}
|
||||
|
||||
private LspStructuralAnchorDTO structuralAnchor(
|
||||
final LspSymbolDTO symbol,
|
||||
final List<PbsToken> tokens) {
|
||||
final List<LspStructuralAnchorDTO> children = new ArrayList<>();
|
||||
for (final LspSymbolDTO child : symbol.children()) {
|
||||
final LspStructuralAnchorDTO anchorChild = structuralAnchor(child, tokens);
|
||||
if (anchorChild != null) {
|
||||
children.add(anchorChild);
|
||||
}
|
||||
}
|
||||
final AnchorPair anchorPair = anchorPair(symbol.range(), tokens);
|
||||
if (anchorPair == null) {
|
||||
if (children.isEmpty()) {
|
||||
return null;
|
||||
}
|
||||
return new LspStructuralAnchorDTO(symbol.range(), symbol.range(), symbol.range(), children);
|
||||
}
|
||||
return new LspStructuralAnchorDTO(symbol.range(), anchorPair.start(), anchorPair.end(), children);
|
||||
}
|
||||
|
||||
private AnchorPair anchorPair(
|
||||
final LspRangeDTO range,
|
||||
final List<PbsToken> tokens) {
|
||||
PbsToken firstLeftBrace = null;
|
||||
PbsToken lastRightBrace = null;
|
||||
for (final PbsToken token : tokens) {
|
||||
if (token.kind() == PbsTokenKind.EOF) {
|
||||
continue;
|
||||
}
|
||||
if (token.start() < range.startOffset() || token.end() > range.endOffset()) {
|
||||
continue;
|
||||
}
|
||||
if (token.kind() == PbsTokenKind.LEFT_BRACE && firstLeftBrace == null) {
|
||||
firstLeftBrace = token;
|
||||
}
|
||||
if (token.kind() == PbsTokenKind.RIGHT_BRACE) {
|
||||
lastRightBrace = token;
|
||||
}
|
||||
}
|
||||
if (firstLeftBrace == null || lastRightBrace == null || lastRightBrace.start() < firstLeftBrace.start()) {
|
||||
return null;
|
||||
}
|
||||
return new AnchorPair(
|
||||
new LspRangeDTO(firstLeftBrace.start(), firstLeftBrace.end()),
|
||||
new LspRangeDTO(lastRightBrace.start(), lastRightBrace.end()));
|
||||
}
|
||||
|
||||
public Map<Path, List<LspHighlightSpanDTO>> semanticHighlightsByDocument() {
|
||||
return Map.copyOf(semanticHighlightsByDocument);
|
||||
}
|
||||
|
||||
public Map<Path, List<LspSymbolDTO>> documentSymbolsByDocument() {
|
||||
return Map.copyOf(documentSymbolsByDocument);
|
||||
}
|
||||
|
||||
public Map<Path, List<LspStructuralAnchorDTO>> structuralAnchorsByDocument() {
|
||||
return Map.copyOf(structuralAnchorsByDocument);
|
||||
}
|
||||
|
||||
public List<LspSymbolDTO> workspaceSymbols() {
|
||||
return List.copyOf(workspaceSymbols);
|
||||
}
|
||||
|
||||
public Map<String, List<LspSymbolDTO>> symbolsByName() {
|
||||
final Map<String, List<LspSymbolDTO>> frozen = new LinkedHashMap<>();
|
||||
for (final var entry : symbolsByName.entrySet()) {
|
||||
frozen.put(entry.getKey(), List.copyOf(entry.getValue()));
|
||||
}
|
||||
return Map.copyOf(frozen);
|
||||
}
|
||||
|
||||
public Map<Path, List<PbsToken>> tokensByDocument() {
|
||||
return Map.copyOf(tokensByDocument);
|
||||
}
|
||||
|
||||
private record AnchorPair(
|
||||
LspRangeDTO start,
|
||||
LspRangeDTO end) {
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user