implements PR006

This commit is contained in:
2026-03-24 13:42:20 +00:00
parent 931c5d96a3
commit f60346e174
9 changed files with 1134 additions and 51 deletions
@@ -0,0 +1,162 @@
package p.studio.compiler.pbs.linking;
import org.junit.jupiter.api.Test;
import p.studio.compiler.pbs.ast.PbsAst;
import p.studio.compiler.pbs.lexer.PbsLexer;
import p.studio.compiler.pbs.parser.PbsBarrelParser;
import p.studio.compiler.pbs.parser.PbsParser;
import p.studio.compiler.source.diagnostics.DiagnosticSink;
import p.studio.compiler.source.identifiers.FileId;
import p.studio.utilities.structures.ReadOnlyList;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
class PbsModuleVisibilityTest {
@Test
void shouldReportMissingBarrelPerModule() {
final var diagnostics = DiagnosticSink.empty();
final var nextFileId = new AtomicInteger(0);
final var module = module("core", "math", List.of(
"""
fn sum(a: int, b: int) -> int { return a + b; }
"""
), null, nextFileId, diagnostics);
new PbsModuleVisibilityValidator().validate(ReadOnlyList.wrap(List.of(module)), diagnostics);
assertTrue(diagnostics.stream().anyMatch(d -> d.getCode().equals(PbsLinkErrors.E_LINK_MISSING_BARREL.name())));
}
@Test
void shouldReportDuplicateBarrelEntriesByKindAndSignature() {
final var diagnostics = DiagnosticSink.empty();
final var nextFileId = new AtomicInteger(0);
final var module = module("core", "math", List.of(
"""
fn foo(x: int) -> int { return x; }
declare struct State(v: int);
"""
), """
pub fn foo(a: int) -> int;
pub fn foo(b: int) -> int;
pub struct State;
pub struct State;
""", nextFileId, diagnostics);
new PbsModuleVisibilityValidator().validate(ReadOnlyList.wrap(List.of(module)), diagnostics);
final long duplicateCount = diagnostics.stream()
.filter(d -> d.getCode().equals(PbsLinkErrors.E_LINK_DUPLICATE_BARREL_ENTRY.name()))
.count();
assertEquals(2, duplicateCount);
}
@Test
void shouldReportUnresolvedBarrelEntries() {
final var diagnostics = DiagnosticSink.empty();
final var nextFileId = new AtomicInteger(0);
final var module = module("core", "math", List.of(
"""
fn foo() -> int { return 1; }
"""
), """
pub fn missing() -> int;
pub enum MissingEnum;
""", nextFileId, diagnostics);
new PbsModuleVisibilityValidator().validate(ReadOnlyList.wrap(List.of(module)), diagnostics);
final long unresolvedCount = diagnostics.stream()
.filter(d -> d.getCode().equals(PbsLinkErrors.E_LINK_UNRESOLVED_BARREL_ENTRY.name()))
.count();
assertEquals(2, unresolvedCount);
}
@Test
void shouldRejectImportOfNonPublicSymbols() {
final var diagnostics = DiagnosticSink.empty();
final var nextFileId = new AtomicInteger(0);
final var moduleMath = module("core", "math", List.of(
"""
fn secret() -> int { return 1; }
fn open() -> int { return 2; }
"""
), """
mod fn secret() -> int;
pub fn open() -> int;
""", nextFileId, diagnostics);
final var moduleApp = module("core", "app", List.of(
"""
import { secret, open } from @core:math;
fn use() -> int { return open(); }
"""
), """
pub fn use() -> int;
""", nextFileId, diagnostics);
new PbsModuleVisibilityValidator().validate(ReadOnlyList.wrap(List.of(moduleMath, moduleApp)), diagnostics);
final var importVisibilityDiagnostics = diagnostics.stream()
.filter(d -> d.getCode().equals(PbsLinkErrors.E_LINK_IMPORT_SYMBOL_NOT_PUBLIC.name()))
.toList();
assertEquals(1, importVisibilityDiagnostics.size());
assertTrue(importVisibilityDiagnostics.getFirst().getMessage().contains("secret"));
}
private PbsModuleVisibilityValidator.ModuleUnit module(
final String project,
final String modulePath,
final List<String> sourceContents,
final String barrelContent,
final AtomicInteger nextFileId,
final DiagnosticSink diagnostics) {
final var sources = new ArrayList<PbsModuleVisibilityValidator.SourceFile>();
for (final var sourceContent : sourceContents) {
final var fileId = new FileId(nextFileId.getAndIncrement());
final var ast = parseSource(sourceContent, fileId, diagnostics);
sources.add(new PbsModuleVisibilityValidator.SourceFile(fileId, ast));
}
final var barrels = new ArrayList<PbsModuleVisibilityValidator.BarrelFile>();
if (barrelContent != null) {
final var fileId = new FileId(nextFileId.getAndIncrement());
final var barrelAst = parseBarrel(barrelContent, fileId, diagnostics);
barrels.add(new PbsModuleVisibilityValidator.BarrelFile(fileId, barrelAst));
}
final var coordinates = new PbsModuleVisibilityValidator.ModuleCoordinates(project, modulePathSegments(modulePath));
return new PbsModuleVisibilityValidator.ModuleUnit(
coordinates,
ReadOnlyList.wrap(sources),
ReadOnlyList.wrap(barrels));
}
private PbsAst.File parseSource(
final String source,
final FileId fileId,
final DiagnosticSink diagnostics) {
return PbsParser.parse(PbsLexer.lex(source, fileId, diagnostics), fileId, diagnostics);
}
private PbsAst.BarrelFile parseBarrel(
final String source,
final FileId fileId,
final DiagnosticSink diagnostics) {
return PbsBarrelParser.parse(PbsLexer.lex(source, fileId, diagnostics), fileId, diagnostics);
}
private ReadOnlyList<String> modulePathSegments(final String modulePath) {
if (modulePath == null || modulePath.isBlank()) {
return ReadOnlyList.empty();
}
return ReadOnlyList.wrap(List.of(modulePath.split("/")));
}
}
@@ -0,0 +1,64 @@
package p.studio.compiler.pbs.parser;
import org.junit.jupiter.api.Test;
import p.studio.compiler.pbs.ast.PbsAst;
import p.studio.compiler.pbs.lexer.PbsLexer;
import p.studio.compiler.source.diagnostics.DiagnosticSink;
import p.studio.compiler.source.identifiers.FileId;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertTrue;
class PbsBarrelParserTest {
@Test
void shouldParseBarrelShapeWithFunctionReturnSurfaces() {
final var source = """
pub fn sum(a: int, b: int) -> int;
mod fn run(state: optional int) -> result<Err> (value: int, meta: float);
pub struct Vec2;
pub callback Tick;
""";
final var diagnostics = DiagnosticSink.empty();
final var fileId = new FileId(0);
final var tokens = PbsLexer.lex(source, fileId, diagnostics);
final var barrel = PbsBarrelParser.parse(tokens, fileId, diagnostics);
assertTrue(diagnostics.isEmpty(), "Valid barrel should parse without diagnostics");
assertEquals(4, barrel.items().size());
final var sum = assertInstanceOf(PbsAst.BarrelFunctionItem.class, barrel.items().get(0));
assertEquals("sum", sum.name());
assertEquals(PbsAst.ReturnKind.PLAIN, sum.returnKind());
assertEquals("int", sum.returnType().name());
assertEquals(2, sum.parameterTypes().size());
final var run = assertInstanceOf(PbsAst.BarrelFunctionItem.class, barrel.items().get(1));
assertEquals(PbsAst.ReturnKind.RESULT, run.returnKind());
assertEquals("Err", run.resultErrorType().name());
assertEquals(PbsAst.TypeRefKind.NAMED_TUPLE, run.returnType().kind());
assertInstanceOf(PbsAst.BarrelStructItem.class, barrel.items().get(2));
assertInstanceOf(PbsAst.BarrelCallbackItem.class, barrel.items().get(3));
}
@Test
void shouldRecoverFromInvalidBarrelItems() {
final var source = """
pub fn ok() -> int;
pub type Invalid;
mod struct Ready;
""";
final var diagnostics = DiagnosticSink.empty();
final var fileId = new FileId(0);
final var barrel = PbsBarrelParser.parse(PbsLexer.lex(source, fileId, diagnostics), fileId, diagnostics);
assertTrue(diagnostics.hasErrors(), "Invalid barrel item should report diagnostics");
assertEquals(2, barrel.items().size());
assertInstanceOf(PbsAst.BarrelFunctionItem.class, barrel.items().get(0));
assertInstanceOf(PbsAst.BarrelStructItem.class, barrel.items().get(1));
}
}