implements PLN-0133
Intrepid/Prometeu/Studio/pipeline/pr-master Build started...
JaCoCo Coverage #### Project Overview No changes detected, that affect the code coverage. * Line Coverage: 62.84% (18504/29445) * Branch Coverage: 53.33% (7215/13528) * Lines of Code: 29445 * Cyclomatic Complexity: 11850 #### Quality Gates Summary Output truncated.
Test / Build skipped: 15, passed: 669
Intrepid/Prometeu/Studio/pipeline/head This commit looks good

Add PBS document symbols as an AST-backed hierarchical outline of
the open .pbs file on FrontendLanguageService. Recovered syntax is
enough; unnamed InvalidDecl is omitted; barrels, imports, locals,
and compile-only frontends stay empty. Advertise documentSymbolProvider
with hierarchical DocumentSymbol.

Housekeep DSC-0041 with LSN-0070.
This commit is contained in:
2026-09-21 10:16:14 +01:00
parent 331ad752d1
commit 5d3d48e802
25 changed files with 1183 additions and 66 deletions
@@ -434,6 +434,131 @@ final class PbsEditorialSupportServiceTest {
return locations;
}
@Test
void shouldBuildAstBackedOutlineHierarchyAndKeepOverloadsAsSiblings() {
final var source = """
import { Log } from @sdk:log;
[Init]
fn init() -> void { return; }
fn helper(a: int) -> int { return a; }
fn helper(a: int, b: int) -> int { return a; }
declare struct Point(x: int, pub y: int) {
ctor make(x: int) { return; }
fn run() -> void { return; }
}
declare contract TickLike { fn tick(dt: int) -> void; }
declare service Physics { fn tick() -> void { return; } }
declare error Io { NotFound; Busy; }
declare enum Mode(Idle = 0, Run = 1);
declare callback OnClick(x: int) -> result<Io> int;
declare global STATE: int = 10;
declare const LIMIT: int = 10;
implements TickLike for Point using s { fn tick(dt: int) -> void { return; } }
fn frame() -> void {
let local = 1;
helper(local);
}
""";
final var ast = parseOrdinary(source);
final var symbols = service.documentSymbols(ast);
assertEquals(List.of(
"init",
"helper",
"helper",
"Point",
"TickLike",
"Physics",
"Io",
"Mode",
"OnClick",
"STATE",
"LIMIT",
"TickLike",
"frame"), names(symbols));
assertTrue(symbols.stream().noneMatch(symbol -> symbol.name().equals("Log") || symbol.name().equals("local")));
assertTrue(symbols.getFirst().name().equals("init"));
assertFalse(symbols.getFirst().name().contains("Init"));
assertEquals("(a: int) -> int", symbols.get(1).detail());
assertEquals("(a: int, b: int) -> int", symbols.get(2).detail());
final var point = requireNamed(symbols, "Point");
assertEquals(PbsEditorialSymbolKind.STRUCT, point.kind());
assertEquals(List.of("x", "y", "make", "run"), names(point.children()));
assertEquals(PbsEditorialSymbolKind.FIELD, point.children().getFirst().kind());
assertEquals("int", point.children().getFirst().detail());
assertEquals(PbsEditorialSymbolKind.CONSTRUCTOR, point.children().get(2).kind());
assertEquals("(x: int)", point.children().get(2).detail());
assertEquals(PbsEditorialSymbolKind.METHOD, point.children().get(3).kind());
final var contract = symbols.get(4);
assertEquals(PbsEditorialSymbolKind.CONTRACT, contract.kind());
assertEquals(List.of("tick"), names(contract.children()));
assertEquals("(dt: int) -> void", contract.children().getFirst().detail());
final var physics = requireNamed(symbols, "Physics");
assertEquals(PbsEditorialSymbolKind.SERVICE, physics.kind());
assertEquals(List.of("tick"), names(physics.children()));
final var error = requireNamed(symbols, "Io");
assertEquals(PbsEditorialSymbolKind.ERROR, error.kind());
assertEquals(List.of("NotFound", "Busy"), names(error.children()));
final var mode = requireNamed(symbols, "Mode");
assertEquals(PbsEditorialSymbolKind.ENUM, mode.kind());
assertEquals(List.of("Idle", "Run"), names(mode.children()));
assertEquals("0", mode.children().getFirst().detail());
final var callback = requireNamed(symbols, "OnClick");
assertEquals(PbsEditorialSymbolKind.CALLBACK, callback.kind());
assertEquals("(x: int) -> result<Io> int", callback.detail());
assertEquals(PbsEditorialSymbolKind.GLOBAL, requireNamed(symbols, "STATE").kind());
assertEquals("int", requireNamed(symbols, "STATE").detail());
assertEquals(PbsEditorialSymbolKind.CONST, requireNamed(symbols, "LIMIT").kind());
final var implementsSymbol = symbols.get(11);
assertEquals("TickLike", implementsSymbol.name());
assertEquals("Point", implementsSymbol.detail());
assertEquals(PbsEditorialSymbolKind.CONTRACT, implementsSymbol.kind());
assertEquals(List.of("tick"), names(implementsSymbol.children()));
}
@Test
void shouldOmitInvalidDeclarationsAndKeepNamedDeclsFromRecoveredAst() {
final var source = """
declare ;
fn ok() -> int { return 1; }
""";
final var ast = parseAllowingErrors(source);
final var symbols = service.documentSymbols(ast);
assertEquals(List.of("ok"), names(symbols));
assertEquals(PbsEditorialSymbolKind.FUNCTION, symbols.getFirst().kind());
}
@Test
void shouldOutlineHostAndBuiltinTypeDeclarationsFromInterfaceModules() {
final var source = """
declare host Gfx {
fn clear(color: int) -> void;
}
declare builtin type Color(
pub r: int
) {
fn pack() -> int;
}
""";
final var ast = parseInterface(source, new FileId(0));
final var symbols = service.documentSymbols(ast);
assertEquals(List.of("Gfx", "Color"), names(symbols));
assertEquals(PbsEditorialSymbolKind.HOST, symbols.getFirst().kind());
assertEquals(List.of("clear"), names(symbols.getFirst().children()));
assertEquals(PbsEditorialSymbolKind.BUILTIN_TYPE, symbols.get(1).kind());
assertEquals(List.of("r", "pack"), names(symbols.get(1).children()));
}
private PbsEditorialResolvedSymbol requireHover(
final String source,
final PbsAst.File ast,
@@ -455,6 +580,26 @@ final class PbsEditorialSupportServiceTest {
return ReadOnlyList.wrap(topDecls);
}
private List<String> names(final List<PbsEditorialDocumentSymbol> symbols) {
return symbols.stream().map(PbsEditorialDocumentSymbol::name).toList();
}
private PbsEditorialDocumentSymbol requireNamed(
final List<PbsEditorialDocumentSymbol> symbols,
final String name) {
return symbols.stream()
.filter(symbol -> symbol.name().equals(name))
.findFirst()
.orElseThrow(() -> new AssertionError("missing symbol: " + name + " in " + names(symbols)));
}
private PbsAst.File parseAllowingErrors(final String source) {
final var diagnostics = DiagnosticSink.empty();
final var fileId = new FileId(0);
final var tokens = PbsLexer.lex(source, fileId, diagnostics);
return PbsParser.parse(tokens, fileId, diagnostics, PbsParser.ParseMode.ORDINARY);
}
private PbsAst.File parseOrdinary(final String source) {
return parse(source, new FileId(0), PbsParser.ParseMode.ORDINARY);
}