feat(pbs): resolve editorial chains and expose read-only external sources
This commit is contained in:
+44
-4
@@ -32,6 +32,7 @@ import p.studio.compiler.services.FrontendDocumentLink;
|
||||
import p.studio.compiler.services.FrontendFoldingRange;
|
||||
import p.studio.compiler.services.FrontendSelectionRange;
|
||||
import p.studio.compiler.services.FrontendDefinitionLocation;
|
||||
import p.studio.compiler.services.FrontendSourceDocument;
|
||||
import p.studio.compiler.services.FrontendDocumentRequest;
|
||||
import p.studio.compiler.services.FrontendDocumentSymbol;
|
||||
import p.studio.compiler.services.FrontendRenameEdit;
|
||||
@@ -63,6 +64,38 @@ import java.util.Objects;
|
||||
import java.util.Optional;
|
||||
|
||||
public final class PBSFrontendLanguageService implements FrontendLanguageService {
|
||||
@Override
|
||||
public boolean supportsExternalSources() { return true; }
|
||||
|
||||
@Override
|
||||
public Optional<FrontendSourceDocument> sourceDocument(
|
||||
final FrontendDocumentRequest request,
|
||||
final FrontendEditorialContext context,
|
||||
final Path path) {
|
||||
if (!(context.projectSurface() instanceof PbsSemanticReadSurface surface)
|
||||
|| !(context.sourceFiles() instanceof FileTableReader files)) return Optional.empty();
|
||||
FrontendSourceDocument projectSource = null;
|
||||
for (final var entry : surface.astByFile().entrySet()) {
|
||||
final var handle = files.get(entry.getKey());
|
||||
if (handle == null || !handle.getCanonPath().toAbsolutePath().normalize().equals(path.toAbsolutePath().normalize())) continue;
|
||||
final var text = handle.readUtf8();
|
||||
if (text.isEmpty()) return Optional.empty();
|
||||
final boolean bundled = surface.sourceKindByFile().get(entry.getKey()) == SourceKind.SDK_INTERFACE;
|
||||
final Path owner = surface.ownerRootByFile().get(entry.getKey());
|
||||
final boolean external = bundled || owner == null || !owner.toAbsolutePath().normalize().equals(request.projectRoot().toAbsolutePath().normalize());
|
||||
final var source = new FrontendSourceDocument(path, text.orElseThrow(),
|
||||
bundled ? "bundled" : external ? "dependency" : "project",
|
||||
handle.getRelativePath().toString(), "pbs", external,
|
||||
new FrontendEditorialContext(entry.getValue(),
|
||||
surface.supplementalTopDeclsByFile().getOrDefault(entry.getKey(), ReadOnlyList.empty()),
|
||||
context.semanticContext(), files, surface));
|
||||
// A dependency may physically overlap a project source root. External
|
||||
// ownership wins even if another file-table entry treats it as local.
|
||||
if (external) return Optional.of(source);
|
||||
projectSource = source;
|
||||
}
|
||||
return Optional.ofNullable(projectSource);
|
||||
}
|
||||
private final PbsEditorialSupportService editorialSupportService;
|
||||
private final PBSSemanticTokenProvider semanticTokenProvider;
|
||||
|
||||
@@ -257,7 +290,12 @@ public final class PBSFrontendLanguageService implements FrontendLanguageService
|
||||
typedSupplementalTopDecls,
|
||||
feSurfaceContext,
|
||||
offset)) {
|
||||
toFrontendLocation(location, fileTable).ifPresent(locations::add);
|
||||
final var handle = fileTable.get(location.span().getFileId());
|
||||
if (handle != null) {
|
||||
sourceDocument(request, editorialContext, handle.getCanonPath()).ifPresent(source ->
|
||||
locations.add(new FrontendDefinitionLocation(source.path(),
|
||||
toOffset(location.span().getStart()), toOffset(location.span().getEnd()), source)));
|
||||
}
|
||||
}
|
||||
return List.copyOf(locations);
|
||||
}
|
||||
@@ -401,14 +439,16 @@ public final class PBSFrontendLanguageService implements FrontendLanguageService
|
||||
}
|
||||
final LinkedHashMap<String, FrontendRenameEdit> edits = new LinkedHashMap<>();
|
||||
for (final PbsEditorialLocation site : planned.sites()) {
|
||||
toFrontendLocation(site, fileTable).ifPresent(location ->
|
||||
edits.putIfAbsent(
|
||||
final var mapped = toFrontendLocation(site, fileTable);
|
||||
if (mapped.isEmpty()) return FrontendRenameResult.refused("rename requires a non-editable source");
|
||||
final var location = mapped.orElseThrow();
|
||||
edits.putIfAbsent(
|
||||
frontendLocationKey(location),
|
||||
new FrontendRenameEdit(
|
||||
location.path(),
|
||||
location.startOffset(),
|
||||
location.endOffset(),
|
||||
newName)));
|
||||
newName));
|
||||
}
|
||||
if (edits.isEmpty()) {
|
||||
return FrontendRenameResult.refused("not renameable");
|
||||
|
||||
+12
@@ -19,6 +19,7 @@ public final class PbsParser {
|
||||
private final PbsTokenCursor cursor;
|
||||
private final PbsTopLevelParser topLevelParser;
|
||||
private final PbsBlockParser blockParser;
|
||||
private final PbsExprParser expressionParser;
|
||||
|
||||
private PbsParser(
|
||||
final ReadOnlyList<PbsToken> tokens,
|
||||
@@ -29,6 +30,7 @@ public final class PbsParser {
|
||||
this.cursor = context.cursor();
|
||||
|
||||
final var exprParser = new PbsExprParser(context, this::parseExpressionSurfaceBlock);
|
||||
this.expressionParser = exprParser;
|
||||
final var attributeParser = new PbsAttributeParser(context, this::isTopLevelRestartToken);
|
||||
final var typeParser = new PbsTypeParser(context);
|
||||
|
||||
@@ -64,6 +66,16 @@ public final class PbsParser {
|
||||
return topLevelParser.parseFile();
|
||||
}
|
||||
|
||||
/** Parses a complete expression fragment using the same grammar as a source file. */
|
||||
public static PbsAst.Expression parseExpression(
|
||||
final ReadOnlyList<PbsToken> tokens,
|
||||
final FileId fileId,
|
||||
final p.studio.compiler.source.diagnostics.DiagnosticSink diagnostics) {
|
||||
final var parser = new PbsParser(tokens, fileId, diagnostics, ParseMode.ORDINARY);
|
||||
final var expression = parser.expressionParser.parseExpression();
|
||||
return parser.cursor.isAtEnd() && !diagnostics.hasErrors() ? expression : null;
|
||||
}
|
||||
|
||||
private PbsAst.Block parseExpressionSurfaceBlock(final String message) {
|
||||
return blockParser.parseBlock(message);
|
||||
}
|
||||
|
||||
+34
@@ -5,6 +5,7 @@ import p.studio.compiler.pbs.ast.PbsAst;
|
||||
import p.studio.compiler.pbs.lexer.PbsLexer;
|
||||
import p.studio.compiler.pbs.lexer.PbsToken;
|
||||
import p.studio.compiler.pbs.lexer.PbsTokenKind;
|
||||
import p.studio.compiler.pbs.parser.PbsParser;
|
||||
import p.studio.compiler.source.Span;
|
||||
import p.studio.compiler.source.diagnostics.DiagnosticSink;
|
||||
import p.studio.compiler.source.identifiers.FileId;
|
||||
@@ -1396,6 +1397,11 @@ public final class PbsEditorialSupportService {
|
||||
private TypeView resolveReceiverTypeBeforeDot(
|
||||
final int dotTokenIndex,
|
||||
final ScopeState scopeState) {
|
||||
final PbsAst.Expression receiver = receiverExpressionBefore(dotTokenIndex);
|
||||
if (receiver != null) {
|
||||
return analyzeExpressionType(receiver, scopeState.scope(), null,
|
||||
scopeState.returnType(), scopeState.resultErrorName(), scopeState.receiverType());
|
||||
}
|
||||
final List<String> segments = resolveChainSegmentsEndingAt(dotTokenIndex - 1);
|
||||
if (segments.isEmpty()) {
|
||||
return TypeView.unknown();
|
||||
@@ -1407,6 +1413,34 @@ public final class PbsEditorialSupportService {
|
||||
return current;
|
||||
}
|
||||
|
||||
private PbsAst.Expression receiverExpressionBefore(final int dotTokenIndex) {
|
||||
// Locate only the fragment boundary here; grammar and overload selection
|
||||
// remain in the existing PBS parser and flow expression analyzer.
|
||||
int start = dotTokenIndex;
|
||||
int depth = 0;
|
||||
for (int index = dotTokenIndex - 1; index >= 0; index--) {
|
||||
final var kind = token(index).kind();
|
||||
if (kind == PbsTokenKind.COMMENT) { start = index; continue; }
|
||||
if (kind == PbsTokenKind.RIGHT_PAREN) {
|
||||
depth++;
|
||||
} else if (kind == PbsTokenKind.LEFT_PAREN) {
|
||||
if (depth == 0) break;
|
||||
depth--;
|
||||
} else if (depth == 0 && kind != PbsTokenKind.IDENTIFIER
|
||||
&& kind != PbsTokenKind.DOT && kind != PbsTokenKind.THIS
|
||||
&& kind != PbsTokenKind.NEW) {
|
||||
break;
|
||||
}
|
||||
start = index;
|
||||
}
|
||||
if (start == dotTokenIndex || depth != 0) return null;
|
||||
final var fragment = new ArrayList<PbsToken>();
|
||||
for (int index = start; index < dotTokenIndex; index++) fragment.add(token(index));
|
||||
final int end = token(dotTokenIndex).start();
|
||||
fragment.add(new PbsToken(PbsTokenKind.EOF, "", end, end));
|
||||
return PbsParser.parseExpression(ReadOnlyList.wrap(fragment), ast.span().getFileId(), DiagnosticSink.empty());
|
||||
}
|
||||
|
||||
private TypeView resolveBaseChainType(
|
||||
final String baseName,
|
||||
final ScopeState scopeState) {
|
||||
|
||||
+7
@@ -132,11 +132,16 @@ public class PBSFrontendPhaseService implements FrontendPhaseService {
|
||||
final Map<FileId, ReadOnlyList<p.studio.compiler.pbs.ast.PbsAst.TopDecl>> supplementalTopDeclsByFile = new LinkedHashMap<>();
|
||||
final Map<FileId, ReadOnlyList<PbsInlineHintSurface>> inlineHintsByFile = new LinkedHashMap<>();
|
||||
final Map<FileId, SourceKind> sourceKindByFile = new LinkedHashMap<>();
|
||||
final Map<FileId, Path> ownerRootByFile = new LinkedHashMap<>();
|
||||
for (final var entry : importedSemanticContexts.entrySet()) {
|
||||
supplementalTopDeclsByFile.put(entry.getKey(), entry.getValue().supplementalTopDecls());
|
||||
}
|
||||
for (final var parsedSourceFile : assembly.parsedSourceFiles()) {
|
||||
astByFile.put(parsedSourceFile.fileId(), parsedSourceFile.ast());
|
||||
final var sourceHandle = ctx.fileTable.get(parsedSourceFile.fileId());
|
||||
if (sourceHandle != null && parsedSourceFile.sourceKind() != SourceKind.SDK_INTERFACE) {
|
||||
ownerRootByFile.put(parsedSourceFile.fileId(), ctx.projectTable.get(sourceHandle.getProjectId()).getRootPath());
|
||||
}
|
||||
sourceKindByFile.put(
|
||||
parsedSourceFile.fileId(),
|
||||
parsedSourceFile.sourceKind() == null ? SourceKind.PROJECT : parsedSourceFile.sourceKind());
|
||||
@@ -158,6 +163,7 @@ public class PBSFrontendPhaseService implements FrontendPhaseService {
|
||||
Map.copyOf(supplementalTopDeclsByFile),
|
||||
Map.copyOf(inlineHintsByFile),
|
||||
Map.copyOf(sourceKindByFile),
|
||||
Map.copyOf(ownerRootByFile),
|
||||
physicalModuleFiles,
|
||||
moduleCompletionLabels(ctx, physicalModuleFiles));
|
||||
}
|
||||
@@ -225,6 +231,7 @@ public class PBSFrontendPhaseService implements FrontendPhaseService {
|
||||
Map<FileId, ReadOnlyList<p.studio.compiler.pbs.ast.PbsAst.TopDecl>> supplementalTopDeclsByFile,
|
||||
Map<FileId, ReadOnlyList<PbsInlineHintSurface>> inlineHintsByFile,
|
||||
Map<FileId, SourceKind> sourceKindByFile,
|
||||
Map<FileId, Path> ownerRootByFile,
|
||||
Map<ModuleReference, Path> physicalModuleFileByReference,
|
||||
List<String> moduleCompletionLabels) {
|
||||
}
|
||||
|
||||
+73
@@ -16,6 +16,79 @@ import static org.junit.jupiter.api.Assertions.*;
|
||||
final class PbsEditorialSupportServiceTest {
|
||||
private final PbsEditorialSupportService service = new PbsEditorialSupportService();
|
||||
|
||||
@Test
|
||||
void receiverMatrixHandlesNestedCallsVariablesParenthesesAndRecovery() {
|
||||
final String declarations = """
|
||||
declare struct Button() { fn down(value: int) -> bool { return true; } }
|
||||
declare struct Pad() { fn left() -> Button { return new Button(); } }
|
||||
fn pad(value: int) -> Pad { return new Pad(); }
|
||||
fn number() -> int { return 1; }
|
||||
""";
|
||||
for (final String receiver : List.of("pad(number()).left()", "(pad(1).left())", "typed", "inferred")) {
|
||||
for (final String suffix : List.of("down(1);", "down(", "")) {
|
||||
final String source = declarations + """
|
||||
fn main() -> void {
|
||||
let typed: Button = new Button();
|
||||
let inferred = pad(1).left();
|
||||
""" + receiver + "." + suffix + "\n}\ndeclare ;";
|
||||
final var ast = parseAllowingErrors(source);
|
||||
final int member = source.lastIndexOf(receiver + ".") + receiver.length() + 1;
|
||||
assertTrue(service.completion(source, ast, ReadOnlyList.empty(), member).stream()
|
||||
.anyMatch(item -> item.label().equals("down")), receiver + "/" + suffix);
|
||||
if (!suffix.isEmpty()) {
|
||||
assertTrue(service.hover(source, ast, ReadOnlyList.empty(), member).isPresent(), receiver);
|
||||
assertFalse(service.definition(source, ast, ReadOnlyList.empty(), member).isEmpty(), receiver);
|
||||
assertTrue(service.signatureHelp(source, ast, ReadOnlyList.empty(), member + 5).isPresent(), receiver);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void ambiguousAndUnknownReceiverDoNotInventMembers() {
|
||||
final String source = """
|
||||
declare struct A() { fn onlyA() -> int { return 1; } }
|
||||
declare struct B() { fn onlyB() -> int { return 2; } }
|
||||
fn choose(value: int) -> A { return new A(); }
|
||||
fn choose(value: int) -> B { return new B(); }
|
||||
fn main() -> void { choose(1).onlyA(); missing().onlyA(); }
|
||||
""";
|
||||
final var ast = parseOrdinary(source);
|
||||
for (final String receiver : List.of("choose(1).", "missing().")) {
|
||||
final int offset = source.indexOf(receiver) + receiver.length();
|
||||
assertTrue(service.hover(source, ast, ReadOnlyList.empty(), offset).isEmpty());
|
||||
assertTrue(service.definition(source, ast, ReadOnlyList.empty(), offset).isEmpty());
|
||||
assertTrue(service.completion(source, ast, ReadOnlyList.empty(), offset).isEmpty());
|
||||
assertTrue(service.signatureHelp(source, ast, ReadOnlyList.empty(), offset + 6).isEmpty());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void chainedReceiversShareTypeResolutionAcrossEditorialQueries() {
|
||||
final String source = """
|
||||
import { Input } from @sdk:input;
|
||||
fn main() -> void {
|
||||
Input.pad().left().down();
|
||||
}
|
||||
""";
|
||||
final var ast = parseOrdinary(source);
|
||||
final var supplemental = supplementalTopDecls("""
|
||||
declare host Input { fn pad() -> Pad; }
|
||||
declare builtin type Pad(pub id: int) { fn left() -> Button; }
|
||||
declare builtin type Button(pub id: int) { fn down() -> bool; }
|
||||
""");
|
||||
final int offset = source.indexOf("down");
|
||||
assertAll(
|
||||
() -> assertEquals("Button", service.hover(source, ast, supplemental, offset)
|
||||
.orElseThrow().origin()),
|
||||
() -> assertEquals(100, service.definition(source, ast, supplemental, offset)
|
||||
.getFirst().span().getFileId().getId()),
|
||||
() -> assertTrue(service.completion(source, ast, supplemental, offset).stream()
|
||||
.anyMatch(candidate -> candidate.label().equals("down"))),
|
||||
() -> assertEquals("down() -> bool", service.signatureHelp(source, ast, supplemental, offset + 5)
|
||||
.orElseThrow().signatures().getFirst().label()));
|
||||
}
|
||||
|
||||
@Test
|
||||
void shouldResolveGeneralCompletionAndHoverAcrossLocalAndImportedSymbols() {
|
||||
final var source = """
|
||||
|
||||
Reference in New Issue
Block a user