implements PR023

This commit is contained in:
2026-03-24 13:42:22 +00:00
parent 213c6a2f76
commit 57f1a617ac
13 changed files with 383 additions and 15 deletions
@@ -0,0 +1,22 @@
package p.studio.compiler.pbs.stdlib;
import p.studio.utilities.structures.ReadOnlyList;
import java.util.Optional;
public final class EmptyStdlibEnvironmentResolver implements StdlibEnvironmentResolver {
private static final StdlibEnvironment EMPTY = new StdlibEnvironment() {
@Override
public Optional<StdlibModuleSource> resolveModule(
final String project,
final ReadOnlyList<String> pathSegments) {
return Optional.empty();
}
};
@Override
public StdlibEnvironment resolve(final int stdlibVersion) {
return EMPTY;
}
}
@@ -0,0 +1,63 @@
package p.studio.compiler.pbs.stdlib;
import p.studio.compiler.pbs.ast.PbsAst;
import p.studio.compiler.pbs.lexer.PbsLexer;
import p.studio.compiler.pbs.linking.PbsModuleVisibilityValidator;
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.concurrent.atomic.AtomicInteger;
public final class InterfaceModuleLoader {
private final AtomicInteger nextSyntheticFileId;
public InterfaceModuleLoader() {
this(1_000_000);
}
public InterfaceModuleLoader(final int firstSyntheticFileId) {
this.nextSyntheticFileId = new AtomicInteger(firstSyntheticFileId);
}
public PbsModuleVisibilityValidator.ModuleUnit load(
final StdlibModuleSource moduleSource,
final DiagnosticSink diagnostics) {
final var sources = new ArrayList<PbsModuleVisibilityValidator.SourceFile>(moduleSource.sourceFiles().size());
for (final var sourceFile : moduleSource.sourceFiles()) {
final var fileId = new FileId(nextSyntheticFileId.getAndIncrement());
final var sourceAst = parseSource(sourceFile.source(), fileId, diagnostics);
sources.add(new PbsModuleVisibilityValidator.SourceFile(fileId, sourceAst));
}
final var barrels = new ArrayList<PbsModuleVisibilityValidator.BarrelFile>(1);
final var barrelFileId = new FileId(nextSyntheticFileId.getAndIncrement());
final var barrelAst = parseBarrel(moduleSource.barrelSource(), barrelFileId, diagnostics);
barrels.add(new PbsModuleVisibilityValidator.BarrelFile(barrelFileId, barrelAst));
return new PbsModuleVisibilityValidator.ModuleUnit(
new PbsModuleVisibilityValidator.ModuleCoordinates(moduleSource.project(), moduleSource.pathSegments()),
ReadOnlyList.wrap(sources),
ReadOnlyList.wrap(barrels));
}
private PbsAst.File parseSource(
final String source,
final FileId fileId,
final DiagnosticSink diagnostics) {
final var tokens = PbsLexer.lex(source, fileId, diagnostics);
return PbsParser.parse(tokens, fileId, diagnostics);
}
private PbsAst.BarrelFile parseBarrel(
final String source,
final FileId fileId,
final DiagnosticSink diagnostics) {
final var tokens = PbsLexer.lex(source, fileId, diagnostics);
return PbsBarrelParser.parse(tokens, fileId, diagnostics);
}
}
@@ -0,0 +1,10 @@
package p.studio.compiler.pbs.stdlib;
import p.studio.utilities.structures.ReadOnlyList;
import java.util.Optional;
public interface StdlibEnvironment {
Optional<StdlibModuleSource> resolveModule(String project, ReadOnlyList<String> pathSegments);
}
@@ -0,0 +1,6 @@
package p.studio.compiler.pbs.stdlib;
public interface StdlibEnvironmentResolver {
StdlibEnvironment resolve(int stdlibVersion);
}
@@ -0,0 +1,29 @@
package p.studio.compiler.pbs.stdlib;
import p.studio.utilities.structures.ReadOnlyList;
import java.util.Objects;
public record StdlibModuleSource(
String project,
ReadOnlyList<String> pathSegments,
ReadOnlyList<SourceFile> sourceFiles,
String barrelSource) {
public StdlibModuleSource {
project = Objects.requireNonNull(project, "project");
pathSegments = pathSegments == null ? ReadOnlyList.empty() : pathSegments;
sourceFiles = sourceFiles == null ? ReadOnlyList.empty() : sourceFiles;
barrelSource = Objects.requireNonNull(barrelSource, "barrelSource");
}
public record SourceFile(
String logicalPath,
String source) {
public SourceFile {
logicalPath = Objects.requireNonNull(logicalPath, "logicalPath");
source = Objects.requireNonNull(source, "source");
}
}
}
@@ -14,6 +14,9 @@ import p.studio.compiler.pbs.linking.PbsLinkErrors;
import p.studio.compiler.pbs.linking.PbsModuleVisibilityValidator;
import p.studio.compiler.pbs.parser.PbsBarrelParser;
import p.studio.compiler.pbs.parser.PbsParser;
import p.studio.compiler.pbs.stdlib.EmptyStdlibEnvironmentResolver;
import p.studio.compiler.pbs.stdlib.InterfaceModuleLoader;
import p.studio.compiler.pbs.stdlib.StdlibEnvironmentResolver;
import p.studio.compiler.source.Span;
import p.studio.compiler.source.diagnostics.DiagnosticSink;
import p.studio.compiler.source.diagnostics.DiagnosticPhase;
@@ -23,6 +26,7 @@ import p.studio.utilities.logs.LogAggregator;
import java.nio.charset.StandardCharsets;
import java.nio.file.Path;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
@@ -34,6 +38,19 @@ import java.util.Set;
public class PBSFrontendPhaseService implements FrontendPhaseService {
private final PbsFrontendCompiler frontendCompiler = new PbsFrontendCompiler();
private final PbsModuleVisibilityValidator moduleVisibilityValidator = new PbsModuleVisibilityValidator();
private final StdlibEnvironmentResolver stdlibEnvironmentResolver;
private final InterfaceModuleLoader interfaceModuleLoader;
public PBSFrontendPhaseService() {
this(new EmptyStdlibEnvironmentResolver(), new InterfaceModuleLoader());
}
PBSFrontendPhaseService(
final StdlibEnvironmentResolver stdlibEnvironmentResolver,
final InterfaceModuleLoader interfaceModuleLoader) {
this.stdlibEnvironmentResolver = stdlibEnvironmentResolver;
this.interfaceModuleLoader = interfaceModuleLoader;
}
@Override
public IRBackend compile(
@@ -99,6 +116,8 @@ public class PBSFrontendPhaseService implements FrontendPhaseService {
}
}
loadReservedStdlibModules(modulesByCoordinates, diagnostics, ctx.stdlibVersion());
final var modules = new ArrayList<PbsModuleVisibilityValidator.ModuleUnit>(modulesByCoordinates.size());
for (final var entry : modulesByCoordinates.entrySet()) {
final var coordinates = entry.getKey();
@@ -127,6 +146,67 @@ public class PBSFrontendPhaseService implements FrontendPhaseService {
return irBackend;
}
private void loadReservedStdlibModules(
final Map<PbsModuleVisibilityValidator.ModuleCoordinates, MutableModuleUnit> modulesByCoordinates,
final DiagnosticSink diagnostics,
final int stdlibVersion) {
final var stdlibEnvironment = stdlibEnvironmentResolver.resolve(stdlibVersion);
final var pending = new ArrayDeque<PbsModuleVisibilityValidator.ModuleCoordinates>();
final var resolved = new HashSet<String>();
enqueueReservedImportsFromKnownModules(modulesByCoordinates, pending);
while (!pending.isEmpty()) {
final var target = pending.removeFirst();
final var targetKey = moduleKey(target);
if (!resolved.add(targetKey)) {
continue;
}
if (modulesByCoordinates.containsKey(target)) {
continue;
}
final var moduleSource = stdlibEnvironment.resolveModule(target.project(), target.pathSegments());
if (moduleSource.isEmpty()) {
continue;
}
final var loadedModule = interfaceModuleLoader.load(moduleSource.get(), diagnostics);
final var moduleData = new MutableModuleUnit();
moduleData.sources.addAll(loadedModule.sourceFiles().asList());
moduleData.barrels.addAll(loadedModule.barrelFiles().asList());
modulesByCoordinates.put(loadedModule.coordinates(), moduleData);
enqueueReservedImportsFromSourceFiles(loadedModule.sourceFiles().asList(), pending);
}
}
private void enqueueReservedImportsFromKnownModules(
final Map<PbsModuleVisibilityValidator.ModuleCoordinates, MutableModuleUnit> modulesByCoordinates,
final ArrayDeque<PbsModuleVisibilityValidator.ModuleCoordinates> pending) {
for (final var moduleUnit : modulesByCoordinates.values()) {
enqueueReservedImportsFromSourceFiles(moduleUnit.sources, pending);
}
}
private void enqueueReservedImportsFromSourceFiles(
final Iterable<PbsModuleVisibilityValidator.SourceFile> sourceFiles,
final ArrayDeque<PbsModuleVisibilityValidator.ModuleCoordinates> pending) {
for (final var source : sourceFiles) {
for (final var importDecl : source.ast().imports()) {
final var moduleRef = importDecl.moduleRef();
if (!isReservedProjectSpace(moduleRef.project())) {
continue;
}
pending.addLast(new PbsModuleVisibilityValidator.ModuleCoordinates(
moduleRef.project(),
moduleRef.pathSegments()));
}
}
}
private boolean isReservedProjectSpace(final String projectName) {
return "core".equals(projectName) || "sdk".equals(projectName);
}
private PbsAst.File parseSourceFile(
final FileId fileId,
final String source,