implements PLN-0125
Intrepid/Prometeu/Studio/pipeline/head This commit looks good
JaCoCo Coverage #### Project Overview No changes detected, that affect the code coverage. * Line Coverage: 61.95% (17766/28676) * Branch Coverage: 52.69% (6860/13019) * Lines of Code: 28676 * Cyclomatic Complexity: 11490 #### Quality Gates Summary Output truncated.
Test / Build skipped: 15, passed: 643
Intrepid/Prometeu/Studio/pipeline/pr-master This commit looks good

Move lifecycle assembly out of the PBS frontend into a common
AssembleLifecyclePipelineStage. PBS emits a typed IRLifecycleDeclaration;
the assembler owns wrappers, boot guard, and single project-init execution.

Housekeep DSC-0059 with LSN-0062, and include the DSC-0062 PVM/PBX
neutrality spec and lesson already present on this branch.
This commit is contained in:
2026-09-19 00:19:45 +01:00
parent c6ef56114f
commit 46bd0c42d3
42 changed files with 2349 additions and 762 deletions
@@ -8,6 +8,9 @@ import p.studio.compiler.models.IRFunction;
import p.studio.compiler.models.IRGlobal;
import p.studio.compiler.models.IRGlobalOrigin;
import p.studio.compiler.models.IRGlobalVisibility;
import p.studio.compiler.models.IRLifecycleCallableReference;
import p.studio.compiler.models.IRLifecycleCallableRole;
import p.studio.compiler.models.IRLifecycleFileDeclaration;
import p.studio.compiler.models.IRReservedMetadata;
import p.studio.compiler.models.IRSyntheticCallableKind;
import p.studio.compiler.models.IRSyntheticFunction;
@@ -215,6 +218,12 @@ public final class PbsFrontendCompiler {
if (fileInitExecutable != null) {
executableFunctions.add(fileInitExecutable);
}
final var lifecycleDeclaration = lowerLifecycleDeclaration(
fileId,
effectiveModuleId,
lifecycleArtifacts,
fileInitExecutable,
executableFunctions);
return new IRBackendFile(
fileId,
functions,
@@ -224,7 +233,8 @@ public final class PbsFrontendCompiler {
reservedMetadata,
effectiveModulePool,
ReadOnlyList.wrap(callableSignatures),
executableLowering.intrinsicPool());
executableLowering.intrinsicPool(),
lifecycleDeclaration);
}
public String callableShapeSurfaceOf(final PbsAst.FunctionDecl functionDecl) {
@@ -306,33 +316,19 @@ public final class PbsFrontendCompiler {
final var frameDecl = lifecycleArtifacts.frameDecl();
final var firstGlobalDecl = lifecycleArtifacts.firstGlobalDecl();
final var fileInitAnchorSpan = initDecl != null ? initDecl.span() : firstGlobalDecl == null ? null : firstGlobalDecl.span();
final var fileInitAnchorName = initDecl != null ? initDecl.name() : firstGlobalDecl == null ? "" : firstGlobalDecl.name();
final var ordinaryFileInit = frameDecl == null ? initDecl : null;
final var fileInitAnchorSpan = ordinaryFileInit != null
? ordinaryFileInit.span()
: firstGlobalDecl == null ? null : firstGlobalDecl.span();
final var fileInitAnchorName = ordinaryFileInit != null
? ordinaryFileInit.name()
: firstGlobalDecl == null ? "" : firstGlobalDecl.name();
if (fileInitAnchorSpan != null) {
syntheticFunctions.add(new IRSyntheticFunction(
moduleId,
fileInitCallableName(fileId),
IRSyntheticCallableKind.FILE_INIT_FRAGMENT,
new IRSyntheticOrigin(fileId, fileInitAnchorName, fileInitAnchorSpan)));
syntheticFunctions.add(new IRSyntheticFunction(
moduleId,
moduleInitCallableName(moduleId),
IRSyntheticCallableKind.MODULE_INIT,
new IRSyntheticOrigin(fileId, fileInitAnchorName, fileInitAnchorSpan)));
}
if (initDecl != null && frameDecl != null) {
syntheticFunctions.add(new IRSyntheticFunction(
moduleId,
projectInitCallableName(moduleId),
IRSyntheticCallableKind.PROJECT_INIT,
new IRSyntheticOrigin(fileId, initDecl.name(), initDecl.span())));
}
if (frameDecl != null) {
syntheticFunctions.add(new IRSyntheticFunction(
moduleId,
frameWrapperCallableName(moduleId),
IRSyntheticCallableKind.PUBLISHED_FRAME_WRAPPER,
new IRSyntheticOrigin(fileId, frameDecl.name(), frameDecl.span())));
}
return ReadOnlyList.wrap(syntheticFunctions);
}
@@ -343,8 +339,10 @@ public final class PbsFrontendCompiler {
final PbsLifecycleArtifacts lifecycleArtifacts,
final ArrayList<IRBackendExecutableFunction> executableFunctions,
final ArrayList<CallableSignatureRef> callableSignatures) {
if (lifecycleArtifacts.firstGlobalDecl() == null
&& lifecycleArtifacts.initDecl() == null) {
final var ordinaryFileInit = lifecycleArtifacts.frameDecl() == null
? lifecycleArtifacts.initDecl()
: null;
if (lifecycleArtifacts.firstGlobalDecl() == null && ordinaryFileInit == null) {
return null;
}
final var syntheticCallableName = fileInitCallableName(fileId);
@@ -352,8 +350,8 @@ public final class PbsFrontendCompiler {
callableSignatures.add(new CallableSignatureRef(moduleId, syntheticCallableName, 0, "() -> unit"));
final var instructions = new ArrayList<IRBackendExecutableFunction.Instruction>();
final var moduleInitSource = lifecycleArtifacts.initDecl();
if (moduleInitSource != null && moduleInitSource != lifecycleArtifacts.frameDecl()) {
final var moduleInitSource = ordinaryFileInit;
if (moduleInitSource != null) {
final var initExecutable = resolveLifecycleExecutable(executableFunctions, moduleId, moduleInitSource.name());
if (initExecutable != null) {
instructions.add(new IRBackendExecutableFunction.Instruction(
@@ -390,6 +388,58 @@ public final class PbsFrontendCompiler {
span);
}
private IRLifecycleFileDeclaration lowerLifecycleDeclaration(
final FileId fileId,
final ModuleId moduleId,
final PbsLifecycleArtifacts lifecycleArtifacts,
final IRBackendExecutableFunction fileInitExecutable,
final ArrayList<IRBackendExecutableFunction> executableFunctions) {
final var fileInitReference = fileInitExecutable == null
? null
: new IRLifecycleCallableReference(
moduleId,
fileId,
fileInitExecutable.callableId(),
IRLifecycleCallableRole.FILE_INIT_FRAGMENT,
fileInitExecutable.span());
final var projectInitSource = lifecycleArtifacts.frameDecl() == null
? null
: lifecycleArtifacts.initDecl();
final var projectInitExecutable = projectInitSource == null
? null
: resolveLifecycleExecutable(executableFunctions, moduleId, projectInitSource.name());
final var projectInitReference = projectInitExecutable == null
? null
: new IRLifecycleCallableReference(
moduleId,
fileId,
projectInitExecutable.callableId(),
IRLifecycleCallableRole.PROJECT_INIT,
projectInitSource.span());
final var frameSource = lifecycleArtifacts.frameDecl();
final var frameExecutable = frameSource == null
? null
: resolveLifecycleExecutable(executableFunctions, moduleId, frameSource.name());
final var frameReference = frameExecutable == null
? null
: new IRLifecycleCallableReference(
moduleId,
fileId,
frameExecutable.callableId(),
IRLifecycleCallableRole.FRAME_ROOT,
frameSource.span());
final var declaration = new IRLifecycleFileDeclaration(
moduleId,
fileId,
fileInitReference,
projectInitReference,
frameReference);
return declaration.isEmpty() ? null : declaration;
}
private IRBackendExecutableFunction resolveLifecycleExecutable(
final ArrayList<IRBackendExecutableFunction> executableFunctions,
final ModuleId moduleId,
@@ -443,27 +493,6 @@ public final class PbsFrontendCompiler {
return "__pbs.file_init$f" + fileId.getId();
}
public static String moduleInitCallableName(final ModuleId moduleId) {
return "__pbs.module_init$m" + normalizedModuleIndex(moduleId);
}
public static String projectInitCallableName(final ModuleId moduleId) {
return "__pbs.project_init$m" + normalizedModuleIndex(moduleId);
}
public static String frameWrapperCallableName(final ModuleId moduleId) {
return "__pbs.frame_wrapper$m" + normalizedModuleIndex(moduleId);
}
public static String bootGuardGlobalName(final ModuleId moduleId) {
return "__pbs.boot_guard$m" + normalizedModuleIndex(moduleId);
}
private static int normalizedModuleIndex(final ModuleId moduleId) {
final var normalized = moduleId == null ? ModuleId.none() : moduleId;
return normalized.isNone() ? -1 : normalized.getIndex();
}
private int safeToInt(final long value) {
if (value > Integer.MAX_VALUE) {
return Integer.MAX_VALUE;
@@ -5,24 +5,15 @@ import p.studio.compiler.messages.BuildingIssueSink;
import p.studio.compiler.messages.FESurfaceContext;
import p.studio.compiler.messages.FrontendPhaseContext;
import p.studio.compiler.models.IRBackend;
import p.studio.compiler.models.IRBackendExecutableFunction;
import p.studio.compiler.models.IRGlobal;
import p.studio.compiler.models.IRGlobalOrigin;
import p.studio.compiler.models.IRGlobalVisibility;
import p.studio.compiler.models.IRHiddenGlobalKind;
import p.studio.compiler.models.IRSyntheticCallableKind;
import p.studio.compiler.pbs.PbsFrontendCompiler;
import p.studio.compiler.pbs.PbsReservedMetadataExtractor;
import p.studio.compiler.pbs.semantics.PbsFlowSemanticsValidator;
import p.studio.compiler.pbs.stdlib.InterfaceModuleLoader;
import p.studio.compiler.pbs.stdlib.ResourceStdlibEnvironmentResolver;
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.identifiers.CallableId;
import p.studio.compiler.source.identifiers.FileId;
import p.studio.compiler.source.identifiers.ModuleId;
import p.studio.compiler.source.tables.CallableSignatureRef;
import p.studio.utilities.logs.LogAggregator;
import p.studio.utilities.structures.ReadOnlyList;
@@ -168,7 +159,7 @@ public class PBSFrontendPhaseService implements FrontendPhaseService {
private IRBackend mergeCompiledSources(
final ArrayList<CompiledSourceFile> compiledSourceFiles,
final Set<ModuleId> failedModuleIds,
final Map<ModuleId, Set<ModuleId>> moduleDependencyGraph) {
final Map<ModuleId, ReadOnlyList<ModuleId>> moduleDependencyGraph) {
final var irBackendAggregator = IRBackend.aggregator();
final var blockedModuleIds = blockedModulesByDependency(failedModuleIds, moduleDependencyGraph);
@@ -178,438 +169,70 @@ public class PBSFrontendPhaseService implements FrontendPhaseService {
}
irBackendAggregator.merge(compiledSource.irBackendFile());
}
return synthesizePublishedLifecycle(irBackendAggregator.emit());
irBackendAggregator.lifecycleModuleOrder(lifecycleModuleOrder(
compiledSourceFiles,
blockedModuleIds,
moduleDependencyGraph));
return irBackendAggregator.emit();
}
private IRBackend synthesizePublishedLifecycle(final IRBackend baseBackend) {
final var callableSignatures = new ArrayList<>(baseBackend.getCallableSignatures().asList());
final var executableFunctions = new ArrayList<>(baseBackend.getExecutableFunctions().asList());
final var globals = new ArrayList<>(baseBackend.getGlobals().asList());
final var fileInitFunctionsByModule = new LinkedHashMap<ModuleId, List<IRBackendExecutableFunction>>();
final var projectInitAnchorsByModule = new LinkedHashMap<ModuleId, String>();
final var wrapperNamesByModule = new LinkedHashMap<ModuleId, String>();
final var frameAnchorsByModule = new LinkedHashMap<ModuleId, String>();
for (final var executable : executableFunctions) {
if (!executable.callableName().startsWith("__pbs.file_init$")) {
continue;
}
fileInitFunctionsByModule
.computeIfAbsent(normalizeModuleId(executable.moduleId()), ignored -> new ArrayList<>())
.add(executable);
}
for (final var syntheticFunction : baseBackend.getSyntheticFunctions()) {
final var moduleId = normalizeModuleId(syntheticFunction.moduleId());
switch (syntheticFunction.kind()) {
case PROJECT_INIT -> projectInitAnchorsByModule.put(moduleId, syntheticFunction.origin().anchorCallableName());
case PUBLISHED_FRAME_WRAPPER -> {
wrapperNamesByModule.put(moduleId, syntheticFunction.callableName());
frameAnchorsByModule.put(moduleId, syntheticFunction.origin().anchorCallableName());
}
default -> {
}
private ReadOnlyList<ModuleId> lifecycleModuleOrder(
final ArrayList<CompiledSourceFile> compiledSourceFiles,
final Set<ModuleId> blockedModuleIds,
final Map<ModuleId, ReadOnlyList<ModuleId>> dependenciesByModule) {
final var availableModules = new LinkedHashSet<ModuleId>();
for (final var compiledSource : compiledSourceFiles) {
if (!blockedModuleIds.contains(compiledSource.moduleId())) {
availableModules.add(compiledSource.moduleId());
}
}
final ModuleId entryPointModuleId;
final String entryPointCallableName;
if (wrapperNamesByModule.size() == 1) {
entryPointModuleId = wrapperNamesByModule.keySet().iterator().next();
entryPointCallableName = wrapperNamesByModule.get(entryPointModuleId);
} else {
entryPointModuleId = baseBackend.getEntryPointModuleId();
entryPointCallableName = baseBackend.getEntryPointCallableName();
}
final var sortedModuleIds = new ArrayList<ModuleId>();
sortedModuleIds.addAll(fileInitFunctionsByModule.keySet());
for (final var moduleId : wrapperNamesByModule.keySet()) {
if (!sortedModuleIds.contains(moduleId)) {
sortedModuleIds.add(moduleId);
}
}
sortedModuleIds.sort(Comparator.comparing(moduleId -> moduleSortKey(baseBackend, moduleId)));
final var moduleInitCallableIds = new LinkedHashMap<ModuleId, CallableId>();
for (final var moduleId : sortedModuleIds) {
final var moduleInitName = PbsFrontendCompiler.moduleInitCallableName(moduleId);
final var fileInitFunctions = new ArrayList<>(fileInitFunctionsByModule.getOrDefault(moduleId, List.of()));
if (fileInitFunctions.isEmpty()) {
continue;
}
fileInitFunctions.sort(Comparator.comparingInt(fn -> fn.fileId().getId()));
final var callableId = new CallableId(callableSignatures.size());
callableSignatures.add(new CallableSignatureRef(moduleId, moduleInitName, 0, "() -> unit"));
moduleInitCallableIds.put(moduleId, callableId);
final var instructions = new ArrayList<IRBackendExecutableFunction.Instruction>();
var anchorSpan = fileInitFunctions.getFirst().span();
var anchorFileId = fileInitFunctions.getFirst().fileId();
for (final var fileInitFunction : fileInitFunctions) {
instructions.add(callInstruction(fileInitFunction, fileInitFunction.span()));
anchorSpan = fileInitFunction.span();
anchorFileId = fileInitFunction.fileId();
}
instructions.add(retInstruction(anchorSpan));
executableFunctions.add(new IRBackendExecutableFunction(
anchorFileId,
final var ordered = new ArrayList<ModuleId>(availableModules.size());
final var visiting = new HashSet<ModuleId>();
final var visited = new HashSet<ModuleId>();
for (final var moduleId : availableModules) {
appendDependenciesFirst(
moduleId,
moduleInitName,
callableId,
safeToInt(anchorSpan.getStart()),
safeToInt(anchorSpan.getEnd()),
0,
0,
0,
1,
ReadOnlyList.wrap(instructions),
anchorSpan));
availableModules,
dependenciesByModule,
visiting,
visited,
ordered);
}
CallableId projectInitCallableId = null;
if (!entryPointModuleId.isNone()) {
final var projectInitAnchor = projectInitAnchorsByModule.get(entryPointModuleId);
final var projectInitTarget = resolveExecutable(executableFunctions, entryPointModuleId, projectInitAnchor);
if (projectInitTarget != null) {
final var projectInitName = PbsFrontendCompiler.projectInitCallableName(entryPointModuleId);
projectInitCallableId = new CallableId(callableSignatures.size());
callableSignatures.add(new CallableSignatureRef(entryPointModuleId, projectInitName, 0, "() -> unit"));
executableFunctions.add(new IRBackendExecutableFunction(
projectInitTarget.fileId(),
entryPointModuleId,
projectInitName,
projectInitCallableId,
projectInitTarget.sourceStart(),
projectInitTarget.sourceEnd(),
0,
0,
0,
1,
ReadOnlyList.from(
callInstruction(projectInitTarget, projectInitTarget.span()),
retInstruction(projectInitTarget.span())),
projectInitTarget.span()));
}
}
final var frameExecutable = resolveExecutable(
executableFunctions,
entryPointModuleId,
frameAnchorsByModule.get(entryPointModuleId));
if (frameExecutable != null
&& entryPointCallableName != null
&& !entryPointCallableName.isBlank()
&& !entryPointModuleId.isNone()) {
final var existingBootGuard = globals.stream()
.filter(global -> moduleIdsMatch(entryPointModuleId, global.moduleId()))
.filter(global -> global.hiddenKind() == IRHiddenGlobalKind.BOOT_GUARD)
.findFirst()
.orElse(null);
final var bootGuardSlot = existingBootGuard != null
? existingBootGuard.slot()
: nextGlobalSlot(globals, entryPointModuleId);
final var wrapperCallableId = new CallableId(callableSignatures.size());
callableSignatures.add(new CallableSignatureRef(entryPointModuleId, entryPointCallableName, 0, "() -> unit"));
final var instructions = new ArrayList<IRBackendExecutableFunction.Instruction>();
instructions.add(getGlobalInstruction(bootGuardSlot, frameExecutable.span()));
instructions.add(pushBoolInstruction(true, frameExecutable.span()));
instructions.add(eqInstruction(frameExecutable.span()));
instructions.add(jumpIfTrueInstruction("bootstrap_done", frameExecutable.span()));
for (final var moduleId : sortedModuleIds) {
final var moduleInitCallableId = moduleInitCallableIds.get(moduleId);
if (moduleInitCallableId == null) {
continue;
}
instructions.add(new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.CALL_FUNC,
moduleId,
PbsFrontendCompiler.moduleInitCallableName(moduleId),
moduleInitCallableId,
null,
null,
0,
0,
frameExecutable.span()));
}
if (projectInitCallableId != null) {
instructions.add(new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.CALL_FUNC,
entryPointModuleId,
PbsFrontendCompiler.projectInitCallableName(entryPointModuleId),
projectInitCallableId,
null,
null,
0,
0,
frameExecutable.span()));
}
instructions.add(pushBoolInstruction(true, frameExecutable.span()));
instructions.add(setGlobalInstruction(bootGuardSlot, frameExecutable.span()));
instructions.add(labelInstruction("bootstrap_done", frameExecutable.span()));
instructions.add(callInstruction(frameExecutable, frameExecutable.span()));
instructions.add(retInstruction(frameExecutable.span()));
executableFunctions.add(new IRBackendExecutableFunction(
frameExecutable.fileId(),
entryPointModuleId,
entryPointCallableName,
wrapperCallableId,
frameExecutable.sourceStart(),
frameExecutable.sourceEnd(),
0,
0,
0,
2,
ReadOnlyList.wrap(instructions),
frameExecutable.span()));
if (existingBootGuard == null) {
globals.add(new IRGlobal(
frameExecutable.fileId(),
entryPointModuleId,
PbsFrontendCompiler.bootGuardGlobalName(entryPointModuleId),
"bool",
bootGuardSlot,
IRGlobalVisibility.MODULE,
true,
IRHiddenGlobalKind.BOOT_GUARD,
new IRGlobalOrigin(
frameExecutable.fileId(),
entryPointModuleId,
frameAnchorsByModule.getOrDefault(entryPointModuleId, frameExecutable.callableName()),
frameExecutable.span(),
"BOOT_GUARD"),
frameExecutable.span()));
}
}
final var normalizedGlobals = normalizeGlobalSlots(globals);
return IRBackend.builder()
.entryPointCallableName(entryPointCallableName)
.entryPointModuleId(entryPointModuleId)
.functions(baseBackend.getFunctions())
.syntheticFunctions(baseBackend.getSyntheticFunctions())
.globals(ReadOnlyList.wrap(normalizedGlobals))
.executableFunctions(ReadOnlyList.wrap(executableFunctions))
.modulePool(baseBackend.getModulePool())
.callableSignatures(ReadOnlyList.wrap(callableSignatures))
.intrinsicPool(baseBackend.getIntrinsicPool())
.reservedMetadata(baseBackend.getReservedMetadata())
.build();
return ReadOnlyList.wrap(ordered);
}
private int nextGlobalSlot(
final ArrayList<IRGlobal> globals,
final ModuleId moduleId) {
var nextSlot = 0;
for (final var global : globals) {
if (!moduleIdsMatch(moduleId, global.moduleId())) {
continue;
}
nextSlot = Math.max(nextSlot, global.slot() + 1);
}
return nextSlot;
}
private ArrayList<IRGlobal> normalizeGlobalSlots(final ArrayList<IRGlobal> globals) {
final var nextSlotByModule = new LinkedHashMap<ModuleId, Integer>();
final var normalized = new ArrayList<IRGlobal>(globals.size());
for (final var global : globals) {
final var moduleId = normalizeModuleId(global.moduleId());
final var slot = nextSlotByModule.getOrDefault(moduleId, 0);
nextSlotByModule.put(moduleId, slot + 1);
normalized.add(new IRGlobal(
global.fileId(),
moduleId,
global.name(),
global.declaredTypeSurface(),
slot,
global.visibility(),
global.isHidden(),
global.hiddenKind(),
global.origin(),
global.span()));
}
return normalized;
}
private IRBackendExecutableFunction resolveExecutable(
final ArrayList<IRBackendExecutableFunction> executableFunctions,
private void appendDependenciesFirst(
final ModuleId moduleId,
final String callableName) {
if (callableName == null || callableName.isBlank()) {
return null;
final Set<ModuleId> availableModules,
final Map<ModuleId, ReadOnlyList<ModuleId>> dependenciesByModule,
final Set<ModuleId> visiting,
final Set<ModuleId> visited,
final ArrayList<ModuleId> ordered) {
if (visited.contains(moduleId) || !availableModules.contains(moduleId)) {
return;
}
for (final var executable : executableFunctions) {
if (!callableName.equals(executable.callableName())) {
continue;
}
if (!moduleIdsMatch(moduleId, executable.moduleId())) {
continue;
}
return executable;
if (!visiting.add(moduleId)) {
return;
}
return null;
}
private IRBackendExecutableFunction.Instruction callInstruction(
final IRBackendExecutableFunction callee,
final Span span) {
return new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.CALL_FUNC,
callee.moduleId(),
callee.callableName(),
callee.callableId(),
null,
null,
callee.paramSlots(),
callee.returnSlots(),
span);
}
private IRBackendExecutableFunction.Instruction retInstruction(final Span span) {
return new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.RET,
"",
null,
null,
span);
}
private IRBackendExecutableFunction.Instruction getGlobalInstruction(
final int slot,
final Span span) {
return new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.GET_GLOBAL,
"",
null,
null,
null,
slot,
null,
span);
}
private IRBackendExecutableFunction.Instruction setGlobalInstruction(
final int slot,
final Span span) {
return new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.SET_GLOBAL,
"",
null,
null,
null,
slot,
null,
span);
}
private IRBackendExecutableFunction.Instruction pushBoolInstruction(
final boolean value,
final Span span) {
return new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.PUSH_BOOL,
"",
null,
null,
null,
value ? "true" : "false",
null,
null,
null,
span);
}
private IRBackendExecutableFunction.Instruction eqInstruction(final Span span) {
return new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.EQ,
"",
null,
null,
null,
span);
}
private IRBackendExecutableFunction.Instruction labelInstruction(
final String label,
final Span span) {
return new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.LABEL,
"",
null,
null,
null,
label,
null,
null,
null,
span);
}
private IRBackendExecutableFunction.Instruction jumpIfTrueInstruction(
final String targetLabel,
final Span span) {
return new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.JMP_IF_TRUE,
"",
null,
null,
null,
null,
targetLabel,
null,
null,
span);
}
private ModuleId normalizeModuleId(final ModuleId moduleId) {
return moduleId == null ? ModuleId.none() : moduleId;
}
private boolean moduleIdsMatch(
final ModuleId left,
final ModuleId right) {
final var normalizedLeft = normalizeModuleId(left);
final var normalizedRight = normalizeModuleId(right);
if (normalizedLeft.isNone() && normalizedRight.isNone()) {
return true;
for (final var dependency : dependenciesByModule.getOrDefault(moduleId, ReadOnlyList.empty())) {
appendDependenciesFirst(
dependency,
availableModules,
dependenciesByModule,
visiting,
visited,
ordered);
}
return !normalizedLeft.isNone()
&& !normalizedRight.isNone()
&& normalizedLeft.getIndex() == normalizedRight.getIndex();
}
private String moduleSortKey(
final IRBackend backend,
final ModuleId moduleId) {
if (moduleId != null && !moduleId.isNone()) {
final var index = moduleId.getIndex();
if (index >= 0 && index < backend.getModulePool().size()) {
final var moduleReference = backend.getModulePool().get(index);
final var joiner = new StringJoiner("/", moduleReference.project() + ":", "");
for (final var segment : moduleReference.pathSegments()) {
joiner.add(segment);
}
return joiner.toString();
}
visiting.remove(moduleId);
if (visited.add(moduleId)) {
ordered.add(moduleId);
}
return "";
}
private int safeToInt(final long value) {
if (value > Integer.MAX_VALUE) {
return Integer.MAX_VALUE;
}
if (value < Integer.MIN_VALUE) {
return Integer.MIN_VALUE;
}
return (int) value;
}
private Set<ModuleId> blockedModulesByDependency(
final Set<ModuleId> failedModuleIds,
final Map<ModuleId, Set<ModuleId>> dependenciesByModule) {
final Map<ModuleId, ReadOnlyList<ModuleId>> dependenciesByModule) {
final Map<ModuleId, Set<ModuleId>> dependentsByModule = new HashMap<>();
for (final var entry : dependenciesByModule.entrySet()) {
final var importer = entry.getKey();
@@ -7,13 +7,14 @@ import p.studio.compiler.source.tables.ModuleTable;
import p.studio.utilities.structures.ReadOnlyList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
record PbsModuleAssembly(
ReadOnlyList<PbsParsedSourceFile> parsedSourceFiles,
Map<ModuleId, Set<ModuleId>> moduleDependencyGraph,
Map<ModuleId, ReadOnlyList<ModuleId>> moduleDependencyGraph,
ReadOnlyList<ModuleReference> canonicalModulePool,
Set<ModuleId> failedModuleIds,
ModuleTable moduleTable,
@@ -26,11 +27,11 @@ record PbsModuleAssembly(
if (moduleDependencyGraph == null || moduleDependencyGraph.isEmpty()) {
moduleDependencyGraph = Map.of();
} else {
final var copiedGraph = new HashMap<ModuleId, Set<ModuleId>>();
final var copiedGraph = new LinkedHashMap<ModuleId, ReadOnlyList<ModuleId>>();
for (final var entry : moduleDependencyGraph.entrySet()) {
copiedGraph.put(entry.getKey(), Set.copyOf(entry.getValue() == null ? Set.of() : entry.getValue()));
copiedGraph.put(entry.getKey(), entry.getValue() == null ? ReadOnlyList.empty() : entry.getValue());
}
moduleDependencyGraph = Map.copyOf(copiedGraph);
moduleDependencyGraph = java.util.Collections.unmodifiableMap(copiedGraph);
}
if (moduleTable == null) {
@@ -353,20 +353,24 @@ final class PbsModuleAssemblyService {
}
}
private Map<ModuleId, Set<ModuleId>> buildModuleDependencyGraph(
private Map<ModuleId, ReadOnlyList<ModuleId>> buildModuleDependencyGraph(
final ArrayList<PbsParsedSourceFile> parsedSourceFiles,
final ModuleTable moduleTable) {
final Map<ModuleId, Set<ModuleId>> dependenciesByModule = new HashMap<>();
final Map<ModuleId, LinkedHashSet<ModuleId>> dependenciesByModule = new LinkedHashMap<>();
for (final var parsedSource : parsedSourceFiles) {
final var moduleDependencies = dependenciesByModule.computeIfAbsent(
parsedSource.moduleId(),
ignored -> new HashSet<>());
ignored -> new LinkedHashSet<>());
for (final var importDecl : parsedSource.ast().imports()) {
final var moduleRef = importDecl.moduleRef();
moduleDependencies.add(moduleId(moduleTable, moduleRef.project(), moduleRef.pathSegments()));
}
}
return dependenciesByModule;
final Map<ModuleId, ReadOnlyList<ModuleId>> ordered = new LinkedHashMap<>();
for (final var entry : dependenciesByModule.entrySet()) {
ordered.put(entry.getKey(), ReadOnlyList.wrap(new ArrayList<>(entry.getValue())));
}
return java.util.Collections.unmodifiableMap(ordered);
}
private ModuleId moduleId(
@@ -8,6 +8,7 @@ import p.studio.compiler.models.IRBackendExecutableFunction;
import p.studio.compiler.models.IRBackendFile;
import p.studio.compiler.models.IRHiddenGlobalKind;
import p.studio.compiler.models.IRGlobalVisibility;
import p.studio.compiler.models.IRLifecycleCallableRole;
import p.studio.compiler.models.IRSyntheticCallableKind;
import p.studio.compiler.models.SourceKind;
import p.studio.compiler.pbs.lexer.LexErrors;
@@ -106,7 +107,7 @@ class PbsFrontendCompilerTest {
}
@Test
void shouldExposeGlobalsAndSyntheticLifecycleArtifactsInBackendFile() {
void shouldExposeGlobalsAndTypedLifecycleDeclarationInBackendFile() {
final var source = """
declare global SCORE: int = 0;
@@ -129,12 +130,20 @@ class PbsFrontendCompilerTest {
assertFalse(fileBackend.globals().getFirst().isHidden());
assertEquals(IRHiddenGlobalKind.NONE, fileBackend.globals().getFirst().hiddenKind());
assertEquals("SCORE", fileBackend.globals().getFirst().origin().derivedFromUserSymbol());
assertEquals(4, fileBackend.syntheticFunctions().size());
assertEquals(1, fileBackend.syntheticFunctions().size());
assertTrue(fileBackend.syntheticFunctions().stream().anyMatch(fn -> fn.kind() == IRSyntheticCallableKind.FILE_INIT_FRAGMENT));
assertTrue(fileBackend.syntheticFunctions().stream().anyMatch(fn -> fn.kind() == IRSyntheticCallableKind.MODULE_INIT));
assertTrue(fileBackend.syntheticFunctions().stream().anyMatch(fn -> fn.kind() == IRSyntheticCallableKind.PROJECT_INIT));
assertTrue(fileBackend.syntheticFunctions().stream().anyMatch(fn -> fn.kind() == IRSyntheticCallableKind.PUBLISHED_FRAME_WRAPPER));
assertTrue(fileBackend.syntheticFunctions().stream().allMatch(fn -> !fn.origin().anchorCallableName().isBlank()));
assertEquals(IRLifecycleCallableRole.FILE_INIT_FRAGMENT,
fileBackend.lifecycleDeclaration().fileInitFragment().role());
assertEquals(IRLifecycleCallableRole.PROJECT_INIT,
fileBackend.lifecycleDeclaration().projectInit().role());
assertEquals(IRLifecycleCallableRole.FRAME_ROOT,
fileBackend.lifecycleDeclaration().frameRoot().role());
final var fileInit = fileBackend.executableFunctions().stream()
.filter(fn -> fn.callableId().equals(fileBackend.lifecycleDeclaration().fileInitFragment().callableId()))
.findFirst()
.orElseThrow();
assertTrue(fileInit.instructions().stream().noneMatch(instruction -> "boot".equals(instruction.calleeCallableName())));
}
@Test
@@ -386,8 +386,10 @@ class PBSFrontendPhaseServiceTest {
assertTrue(diagnostics.isEmpty());
assertEquals(2, irBackend.getFunctions().size());
assertTrue(irBackend.getExecutableFunctions().stream().anyMatch(function -> "frame".equals(function.callableName())));
assertTrue(irBackend.getExecutableFunctions().stream().anyMatch(function ->
function.callableName().startsWith("__pbs.frame_wrapper$m")));
assertNotNull(irBackend.getLifecycleDeclaration());
assertEquals(IRLifecycleCallableRole.FRAME_ROOT, irBackend.getLifecycleDeclaration().frameRoot().role());
assertTrue(irBackend.getSyntheticFunctions().stream().noneMatch(function ->
function.kind() == IRSyntheticCallableKind.PUBLISHED_FRAME_WRAPPER));
}
@Test
@@ -483,36 +485,19 @@ class PBSFrontendPhaseServiceTest {
BuildingIssueSink.empty());
assertTrue(diagnostics.isEmpty(), diagnostics.stream().map(d -> d.getCode() + ":" + d.getMessage()).toList().toString());
assertTrue(irBackend.getEntryPointCallableName().startsWith("__pbs.frame_wrapper$m"));
assertNotNull(irBackend.getLifecycleDeclaration());
assertEquals(IRLifecycleCallableRole.PROJECT_INIT, irBackend.getLifecycleDeclaration().projectInit().role());
assertEquals(IRLifecycleCallableRole.FRAME_ROOT, irBackend.getLifecycleDeclaration().frameRoot().role());
final var scoreGlobal = irBackend.getGlobals().stream()
.filter(global -> "SCORE".equals(global.name()))
.findFirst()
.orElseThrow();
assertEquals(IRGlobalVisibility.PUBLIC, scoreGlobal.visibility());
final var bootGuard = irBackend.getGlobals().stream()
.filter(global -> global.hiddenKind() == IRHiddenGlobalKind.BOOT_GUARD)
.findFirst()
.orElseThrow();
assertTrue(bootGuard.isHidden());
assertEquals(IRGlobalVisibility.MODULE, bootGuard.visibility());
assertTrue(bootGuard.name().startsWith("__pbs.boot_guard$m"));
assertEquals(1, bootGuard.slot());
final var wrapper = irBackend.getExecutableFunctions().stream()
.filter(function -> irBackend.getEntryPointCallableName().equals(function.callableName()))
.findFirst()
.orElseThrow();
assertEquals(11, wrapper.instructions().size());
assertEquals(p.studio.compiler.models.IRBackendExecutableFunction.InstructionKind.GET_GLOBAL, wrapper.instructions().get(0).kind());
assertEquals(p.studio.compiler.models.IRBackendExecutableFunction.InstructionKind.PUSH_BOOL, wrapper.instructions().get(1).kind());
assertEquals(p.studio.compiler.models.IRBackendExecutableFunction.InstructionKind.EQ, wrapper.instructions().get(2).kind());
assertEquals(p.studio.compiler.models.IRBackendExecutableFunction.InstructionKind.JMP_IF_TRUE, wrapper.instructions().get(3).kind());
assertTrue(wrapper.instructions().get(4).calleeCallableName().startsWith("__pbs.module_init$m"));
assertTrue(wrapper.instructions().get(5).calleeCallableName().startsWith("__pbs.project_init$m"));
assertEquals(p.studio.compiler.models.IRBackendExecutableFunction.InstructionKind.PUSH_BOOL, wrapper.instructions().get(6).kind());
assertEquals(p.studio.compiler.models.IRBackendExecutableFunction.InstructionKind.SET_GLOBAL, wrapper.instructions().get(7).kind());
assertEquals(p.studio.compiler.models.IRBackendExecutableFunction.InstructionKind.LABEL, wrapper.instructions().get(8).kind());
assertEquals("frame", wrapper.instructions().get(9).calleeCallableName());
assertEquals(p.studio.compiler.models.IRBackendExecutableFunction.InstructionKind.RET, wrapper.instructions().get(10).kind());
assertTrue(irBackend.getGlobals().stream().noneMatch(global -> global.hiddenKind() == IRHiddenGlobalKind.BOOT_GUARD));
assertTrue(irBackend.getSyntheticFunctions().stream().noneMatch(function ->
function.kind() == IRSyntheticCallableKind.MODULE_INIT
|| function.kind() == IRSyntheticCallableKind.PROJECT_INIT
|| function.kind() == IRSyntheticCallableKind.PUBLISHED_FRAME_WRAPPER));
}
@Test
@@ -572,16 +557,100 @@ class PBSFrontendPhaseServiceTest {
BuildingIssueSink.empty());
assertTrue(diagnostics.isEmpty(), diagnostics.stream().map(d -> d.getCode() + ":" + d.getMessage()).toList().toString());
assertTrue(irBackend.getEntryPointCallableName().startsWith("__pbs.frame_wrapper$m"));
assertNotNull(irBackend.getLifecycleDeclaration());
assertTrue(irBackend.getExecutableFunctions().stream().anyMatch(function ->
function.callableName().startsWith("__pbs.file_init$f")));
assertTrue(irBackend.getExecutableFunctions().stream().anyMatch(function ->
function.callableName().startsWith("__pbs.module_init$m")));
assertTrue(irBackend.getExecutableFunctions().stream().anyMatch(function ->
function.callableName().startsWith("__pbs.project_init$m")));
assertEquals(1, irBackend.getLifecycleDeclaration().modules().getFirst().fileInitFragments().size());
assertEquals(IRLifecycleCallableRole.PROJECT_INIT, irBackend.getLifecycleDeclaration().projectInit().role());
assertEquals(IRLifecycleCallableRole.FRAME_ROOT, irBackend.getLifecycleDeclaration().frameRoot().role());
assertTrue(irBackend.getGlobals().stream().anyMatch(global ->
"SCORE".equals(global.name()) && global.visibility() == IRGlobalVisibility.PUBLIC));
assertTrue(irBackend.getGlobals().stream().anyMatch(global -> global.hiddenKind() == IRHiddenGlobalKind.BOOT_GUARD));
assertTrue(irBackend.getGlobals().stream().noneMatch(global -> global.hiddenKind() == IRHiddenGlobalKind.BOOT_GUARD));
}
@Test
void shouldPublishDependencyOrderedLifecycleModulesInsteadOfNameOrFileIdOrder() throws IOException {
final var projectRoot = tempDir.resolve("project-lifecycle-dep-order");
final var sourceRoot = projectRoot.resolve("src");
final var zzzPath = sourceRoot.resolve("zzz");
final var aaaPath = sourceRoot.resolve("aaa");
Files.createDirectories(zzzPath);
Files.createDirectories(aaaPath);
final var zzzSource = zzzPath.resolve("source.pbs");
final var zzzBarrel = zzzPath.resolve("mod.barrel");
Files.writeString(zzzSource, """
declare global WARM: int = 1;
[Init]
fn warmup() -> void { return; }
""");
Files.writeString(zzzBarrel, """
pub fn warmup() -> void;
pub global WARM;
""");
final var aaaSource = aaaPath.resolve("source.pbs");
final var aaaBarrel = aaaPath.resolve("mod.barrel");
Files.writeString(aaaSource, """
import { warmup } from @app:zzz;
[Init]
fn boot() -> void {
warmup();
return;
}
[Frame]
fn frame() -> void { return; }
""");
Files.writeString(aaaBarrel, """
pub fn boot() -> void;
pub fn frame() -> void;
""");
final var projectTable = new ProjectTable();
final var fileTable = new FileTable(1);
final var projectId = projectTable.register(ProjectDescriptor.builder()
.rootPath(projectRoot)
.name("app")
.version("1.0.0")
.sourceRoots(ReadOnlyList.wrap(List.of(sourceRoot)))
.build());
registerFile(projectId, projectRoot, aaaSource, fileTable);
registerFile(projectId, projectRoot, aaaBarrel, fileTable);
registerFile(projectId, projectRoot, zzzSource, fileTable);
registerFile(projectId, projectRoot, zzzBarrel, fileTable);
final var ctx = new FrontendPhaseContext(
projectTable,
fileTable,
new BuildStack(ReadOnlyList.wrap(List.of(projectId))),
AppMode.Game);
final var diagnostics = DiagnosticSink.empty();
final var irBackend = new PBSFrontendPhaseService().compile(
ctx,
diagnostics,
LogAggregator.empty(),
BuildingIssueSink.empty());
assertEquals(0, diagnostics.errorCount(), diagnostics.stream().map(d -> d.getCode() + ":" + d.getMessage()).toList().toString());
final var declaration = irBackend.getLifecycleDeclaration();
assertNotNull(declaration);
assertEquals(2, declaration.modules().size());
final var firstModule = irBackend.getModulePool().get(declaration.modules().get(0).moduleId().getIndex());
final var secondModule = irBackend.getModulePool().get(declaration.modules().get(1).moduleId().getIndex());
assertEquals("zzz", firstModule.pathSegments().getFirst());
assertEquals("aaa", secondModule.pathSegments().getFirst());
assertFalse(declaration.modules().get(0).fileInitFragments().isEmpty());
assertEquals(IRLifecycleCallableRole.PROJECT_INIT, declaration.projectInit().role());
assertEquals(IRLifecycleCallableRole.FRAME_ROOT, declaration.frameRoot().role());
assertTrue(irBackend.getSyntheticFunctions().stream().noneMatch(function ->
function.kind() == IRSyntheticCallableKind.MODULE_INIT
|| function.kind() == IRSyntheticCallableKind.PROJECT_INIT
|| function.kind() == IRSyntheticCallableKind.PUBLISHED_FRAME_WRAPPER));
}
@Test
@@ -500,6 +500,8 @@ public class LowerToIRVMService {
}
private void validateCommonLifecycleStructure(final IRBackend backend) {
// Backend precondition on an already-assembled handoff. Declaration
// validation and materialization belong to LifecycleAssemblerService.
if (backend.getSyntheticFunctions().isEmpty()) {
return;
}
@@ -0,0 +1,532 @@
package p.studio.compiler.lifecycle;
import p.studio.compiler.messages.BuildingIssueSink;
import p.studio.compiler.models.*;
import p.studio.compiler.source.Span;
import p.studio.compiler.source.identifiers.CallableId;
import p.studio.compiler.source.identifiers.ModuleId;
import p.studio.compiler.source.tables.CallableSignatureRef;
import p.studio.utilities.structures.ReadOnlyList;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Set;
public final class LifecycleAssemblerService {
public static final String PHASE = "lifecycle-assembly";
public static final String INVALID_DECLARATION = "COMMON_LIFECYCLE_INVALID_DECLARATION";
public IRBackend assemble(
final IRBackend backend,
final BuildingIssueSink issues) {
if (backend == null) {
report(issues, null, "IRBackend is required for lifecycle assembly");
return null;
}
final var declaration = backend.getLifecycleDeclaration();
if (declaration == null) {
return backend;
}
if (!validate(backend, declaration, issues)) {
return backend;
}
final var callableSignatures = new ArrayList<>(backend.getCallableSignatures().asList());
final var executableFunctions = new ArrayList<>(backend.getExecutableFunctions().asList());
final var syntheticFunctions = new ArrayList<>(backend.getSyntheticFunctions().asList());
final var globals = new ArrayList<>(backend.getGlobals().asList());
final var moduleInitCallableIds = new LinkedHashMap<ModuleId, CallableId>();
for (final var module : declaration.modules()) {
if (module.fileInitFragments().isEmpty()) {
continue;
}
final var moduleId = module.moduleId();
final var moduleInitName = moduleInitCallableName(moduleId);
final var moduleInitCallableId = new CallableId(callableSignatures.size());
callableSignatures.add(new CallableSignatureRef(moduleId, moduleInitName, 0, "() -> unit"));
moduleInitCallableIds.put(moduleId, moduleInitCallableId);
final var instructions = new ArrayList<IRBackendExecutableFunction.Instruction>();
IRBackendExecutableFunction anchor = null;
for (final var fragment : module.fileInitFragments()) {
final var executable = resolveExecutable(backend, fragment);
instructions.add(callInstruction(executable, fragment.origin()));
anchor = executable;
}
instructions.add(retInstruction(anchor.span()));
executableFunctions.add(new IRBackendExecutableFunction(
anchor.fileId(),
moduleId,
moduleInitName,
moduleInitCallableId,
anchor.sourceStart(),
anchor.sourceEnd(),
0,
0,
0,
1,
ReadOnlyList.wrap(instructions),
anchor.span()));
syntheticFunctions.add(new IRSyntheticFunction(
moduleId,
moduleInitName,
IRSyntheticCallableKind.MODULE_INIT,
new IRSyntheticOrigin(anchor.fileId(), anchor.callableName(), anchor.span())));
}
final var frameExecutable = resolveExecutable(backend, declaration.frameRoot());
final var entryPointModuleId = frameExecutable.moduleId();
CallableId projectInitCallableId = null;
if (declaration.projectInit() != null) {
final var projectInitTarget = resolveExecutable(backend, declaration.projectInit());
final var projectInitName = projectInitCallableName(entryPointModuleId);
projectInitCallableId = new CallableId(callableSignatures.size());
callableSignatures.add(new CallableSignatureRef(
entryPointModuleId,
projectInitName,
0,
"() -> unit"));
executableFunctions.add(new IRBackendExecutableFunction(
projectInitTarget.fileId(),
entryPointModuleId,
projectInitName,
projectInitCallableId,
projectInitTarget.sourceStart(),
projectInitTarget.sourceEnd(),
0,
0,
0,
1,
ReadOnlyList.from(
callInstruction(projectInitTarget, projectInitTarget.span()),
retInstruction(projectInitTarget.span())),
projectInitTarget.span()));
syntheticFunctions.add(new IRSyntheticFunction(
entryPointModuleId,
projectInitName,
IRSyntheticCallableKind.PROJECT_INIT,
new IRSyntheticOrigin(
projectInitTarget.fileId(),
projectInitTarget.callableName(),
projectInitTarget.span())));
}
final var entryPointCallableName = frameWrapperCallableName(entryPointModuleId);
final var bootGuardSlot = nextGlobalSlot(globals, entryPointModuleId);
final var wrapperCallableId = new CallableId(callableSignatures.size());
callableSignatures.add(new CallableSignatureRef(
entryPointModuleId,
entryPointCallableName,
0,
"() -> unit"));
final var wrapperInstructions = new ArrayList<IRBackendExecutableFunction.Instruction>();
wrapperInstructions.add(getGlobalInstruction(bootGuardSlot, frameExecutable.span()));
wrapperInstructions.add(pushBoolInstruction(true, frameExecutable.span()));
wrapperInstructions.add(eqInstruction(frameExecutable.span()));
wrapperInstructions.add(jumpIfTrueInstruction("bootstrap_done", frameExecutable.span()));
for (final var module : declaration.modules()) {
final var moduleInitCallableId = moduleInitCallableIds.get(module.moduleId());
if (moduleInitCallableId == null) {
continue;
}
wrapperInstructions.add(new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.CALL_FUNC,
module.moduleId(),
moduleInitCallableName(module.moduleId()),
moduleInitCallableId,
null,
null,
0,
0,
frameExecutable.span()));
}
if (projectInitCallableId != null) {
wrapperInstructions.add(new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.CALL_FUNC,
entryPointModuleId,
projectInitCallableName(entryPointModuleId),
projectInitCallableId,
null,
null,
0,
0,
frameExecutable.span()));
}
wrapperInstructions.add(pushBoolInstruction(true, frameExecutable.span()));
wrapperInstructions.add(setGlobalInstruction(bootGuardSlot, frameExecutable.span()));
wrapperInstructions.add(labelInstruction("bootstrap_done", frameExecutable.span()));
wrapperInstructions.add(callInstruction(frameExecutable, frameExecutable.span()));
wrapperInstructions.add(retInstruction(frameExecutable.span()));
executableFunctions.add(new IRBackendExecutableFunction(
frameExecutable.fileId(),
entryPointModuleId,
entryPointCallableName,
wrapperCallableId,
frameExecutable.sourceStart(),
frameExecutable.sourceEnd(),
0,
0,
0,
2,
ReadOnlyList.wrap(wrapperInstructions),
frameExecutable.span()));
syntheticFunctions.add(new IRSyntheticFunction(
entryPointModuleId,
entryPointCallableName,
IRSyntheticCallableKind.PUBLISHED_FRAME_WRAPPER,
new IRSyntheticOrigin(
frameExecutable.fileId(),
frameExecutable.callableName(),
frameExecutable.span())));
globals.add(new IRGlobal(
frameExecutable.fileId(),
entryPointModuleId,
bootGuardGlobalName(entryPointModuleId),
"bool",
bootGuardSlot,
IRGlobalVisibility.MODULE,
true,
IRHiddenGlobalKind.BOOT_GUARD,
new IRGlobalOrigin(
frameExecutable.fileId(),
entryPointModuleId,
frameExecutable.callableName(),
frameExecutable.span(),
"BOOT_GUARD"),
frameExecutable.span()));
return IRBackend.builder()
.entryPointCallableName(entryPointCallableName)
.entryPointModuleId(entryPointModuleId)
.functions(backend.getFunctions())
.syntheticFunctions(ReadOnlyList.wrap(syntheticFunctions))
.globals(ReadOnlyList.wrap(normalizeGlobalSlots(globals)))
.executableFunctions(ReadOnlyList.wrap(executableFunctions))
.modulePool(backend.getModulePool())
.callableSignatures(ReadOnlyList.wrap(callableSignatures))
.intrinsicPool(backend.getIntrinsicPool())
.reservedMetadata(backend.getReservedMetadata())
.lifecycleDeclaration(declaration)
.build();
}
private boolean validate(
final IRBackend backend,
final IRLifecycleDeclaration declaration,
final BuildingIssueSink issues) {
var valid = true;
for (final var synthetic : backend.getSyntheticFunctions()) {
if (synthetic.kind() != IRSyntheticCallableKind.FILE_INIT_FRAGMENT) {
report(issues, synthetic.origin().span(),
"frontend handoff contains pre-materialized lifecycle artifact: " + synthetic.kind());
valid = false;
}
}
for (final var global : backend.getGlobals()) {
if (global.hiddenKind() == IRHiddenGlobalKind.BOOT_GUARD) {
report(issues, global.span(), "frontend handoff contains pre-materialized boot guard");
valid = false;
}
}
final Set<Integer> moduleIds = new HashSet<>();
final Set<Integer> lifecycleCallableIds = new HashSet<>();
for (final var module : declaration.modules()) {
final var moduleIndex = module.moduleId().isNone() ? -1 : module.moduleId().getIndex();
if (!moduleIds.add(moduleIndex)) {
report(issues, null, "duplicate lifecycle module: " + moduleIndex);
valid = false;
}
for (final var fragment : module.fileInitFragments()) {
valid &= validateReference(
backend,
fragment,
IRLifecycleCallableRole.FILE_INIT_FRAGMENT,
module.moduleId(),
lifecycleCallableIds,
issues);
}
}
if (declaration.projectInit() != null) {
valid &= validateReference(
backend,
declaration.projectInit(),
IRLifecycleCallableRole.PROJECT_INIT,
declaration.projectInit().moduleId(),
lifecycleCallableIds,
issues);
}
if (declaration.frameRoot() == null) {
report(issues, null, "executable lifecycle declaration is missing frame root");
valid = false;
} else {
valid &= validateReference(
backend,
declaration.frameRoot(),
IRLifecycleCallableRole.FRAME_ROOT,
declaration.frameRoot().moduleId(),
lifecycleCallableIds,
issues);
}
return valid;
}
private boolean validateReference(
final IRBackend backend,
final IRLifecycleCallableReference reference,
final IRLifecycleCallableRole expectedRole,
final ModuleId expectedModuleId,
final Set<Integer> lifecycleCallableIds,
final BuildingIssueSink issues) {
if (reference == null) {
report(issues, null, "missing lifecycle reference for role " + expectedRole);
return false;
}
var valid = true;
if (reference.role() != expectedRole) {
report(issues, reference.origin(), "incompatible lifecycle role: expected "
+ expectedRole + " but found " + reference.role());
valid = false;
}
if (!sameModuleId(reference.moduleId(), expectedModuleId)) {
report(issues, reference.origin(), "lifecycle reference module does not match declaration module");
valid = false;
}
if (reference.origin() == null || reference.origin().isNone()) {
report(issues, reference.origin(), "lifecycle reference origin is missing for role " + expectedRole);
valid = false;
}
final var callableIndex = reference.callableId().getIndex();
if (!lifecycleCallableIds.add(callableIndex)) {
report(issues, reference.origin(), "callable is assigned to multiple lifecycle roles: " + callableIndex);
valid = false;
}
if (callableIndex < 0 || callableIndex >= backend.getCallableSignatures().size()) {
report(issues, reference.origin(), "unresolved lifecycle callable id: " + callableIndex);
return false;
}
final var signature = backend.getCallableSignatures().get(callableIndex);
if (!sameModuleId(signature.moduleId(), reference.moduleId())) {
report(issues, reference.origin(), "lifecycle callable signature module mismatch: " + callableIndex);
valid = false;
}
if (resolveExecutable(backend, reference) == null) {
report(issues, reference.origin(), "lifecycle callable has no executable body: " + callableIndex);
valid = false;
}
return valid;
}
private IRBackendExecutableFunction resolveExecutable(
final IRBackend backend,
final IRLifecycleCallableReference reference) {
if (reference == null) {
return null;
}
for (final var executable : backend.getExecutableFunctions()) {
if (executable.callableId().getIndex() == reference.callableId().getIndex()
&& sameModuleId(executable.moduleId(), reference.moduleId())) {
return executable;
}
}
return null;
}
private void report(
final BuildingIssueSink issues,
final Span span,
final String message) {
final var effectiveSpan = span == null ? Span.none() : span;
issues.report(builder -> builder
.error(true)
.phase(PHASE)
.code(INVALID_DECLARATION)
.fileId(effectiveSpan.getFileId().isNone() ? null : effectiveSpan.getFileId().getId())
.start(safeToInt(effectiveSpan.getStart()))
.end(safeToInt(effectiveSpan.getEnd()))
.message(message));
}
private int nextGlobalSlot(
final ArrayList<IRGlobal> globals,
final ModuleId moduleId) {
var nextSlot = 0;
for (final var global : globals) {
if (sameModuleId(moduleId, global.moduleId())) {
nextSlot = Math.max(nextSlot, global.slot() + 1);
}
}
return nextSlot;
}
private ArrayList<IRGlobal> normalizeGlobalSlots(final ArrayList<IRGlobal> globals) {
final var nextSlotByModule = new LinkedHashMap<ModuleId, Integer>();
final var normalized = new ArrayList<IRGlobal>(globals.size());
for (final var global : globals) {
final var moduleId = normalizeModuleId(global.moduleId());
final var slot = nextSlotByModule.getOrDefault(moduleId, 0);
nextSlotByModule.put(moduleId, slot + 1);
normalized.add(new IRGlobal(
global.fileId(),
moduleId,
global.name(),
global.declaredTypeSurface(),
slot,
global.visibility(),
global.isHidden(),
global.hiddenKind(),
global.origin(),
global.span()));
}
return normalized;
}
private IRBackendExecutableFunction.Instruction callInstruction(
final IRBackendExecutableFunction callee,
final Span span) {
return new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.CALL_FUNC,
callee.moduleId(),
callee.callableName(),
callee.callableId(),
null,
null,
callee.paramSlots(),
callee.returnSlots(),
span);
}
private IRBackendExecutableFunction.Instruction retInstruction(final Span span) {
return new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.RET,
"",
null,
null,
span);
}
private IRBackendExecutableFunction.Instruction getGlobalInstruction(final int slot, final Span span) {
return new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.GET_GLOBAL,
"",
null,
null,
null,
slot,
null,
span);
}
private IRBackendExecutableFunction.Instruction setGlobalInstruction(final int slot, final Span span) {
return new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.SET_GLOBAL,
"",
null,
null,
null,
slot,
null,
span);
}
private IRBackendExecutableFunction.Instruction pushBoolInstruction(final boolean value, final Span span) {
return new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.PUSH_BOOL,
"",
null,
null,
null,
value ? "true" : "false",
null,
null,
null,
span);
}
private IRBackendExecutableFunction.Instruction eqInstruction(final Span span) {
return new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.EQ,
"",
null,
null,
null,
span);
}
private IRBackendExecutableFunction.Instruction labelInstruction(final String label, final Span span) {
return new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.LABEL,
"",
null,
null,
null,
label,
null,
null,
null,
span);
}
private IRBackendExecutableFunction.Instruction jumpIfTrueInstruction(final String label, final Span span) {
return new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.JMP_IF_TRUE,
"",
null,
null,
null,
null,
label,
null,
null,
span);
}
private ModuleId normalizeModuleId(final ModuleId moduleId) {
return moduleId == null ? ModuleId.none() : moduleId;
}
private boolean sameModuleId(final ModuleId left, final ModuleId right) {
final var normalizedLeft = normalizeModuleId(left);
final var normalizedRight = normalizeModuleId(right);
if (normalizedLeft.isNone() || normalizedRight.isNone()) {
return normalizedLeft.isNone() && normalizedRight.isNone();
}
return normalizedLeft.getIndex() == normalizedRight.getIndex();
}
private String moduleInitCallableName(final ModuleId moduleId) {
return "__prometeu.lifecycle.module_init$m" + normalizedModuleIndex(moduleId);
}
private String projectInitCallableName(final ModuleId moduleId) {
return "__prometeu.lifecycle.project_init$m" + normalizedModuleIndex(moduleId);
}
private String frameWrapperCallableName(final ModuleId moduleId) {
return "__prometeu.lifecycle.frame_wrapper$m" + normalizedModuleIndex(moduleId);
}
private String bootGuardGlobalName(final ModuleId moduleId) {
return "__prometeu.lifecycle.boot_guard$m" + normalizedModuleIndex(moduleId);
}
private int normalizedModuleIndex(final ModuleId moduleId) {
final var normalized = normalizeModuleId(moduleId);
return normalized.isNone() ? -1 : normalized.getIndex();
}
private int safeToInt(final long value) {
if (value > Integer.MAX_VALUE) {
return Integer.MAX_VALUE;
}
if (value < Integer.MIN_VALUE) {
return Integer.MIN_VALUE;
}
return (int) value;
}
}
@@ -23,7 +23,8 @@ public class BuilderPipelineService {
final var analyses = List.<PipelineStage>of(
new ResolveDepsPipelineStage(),
new LoadSourcesPipelineStage(),
new FrontendPhasePipelineStage()
new FrontendPhasePipelineStage(),
new AssembleLifecyclePipelineStage()
);
final var compile = List.<PipelineStage>of(
@@ -0,0 +1,32 @@
package p.studio.compiler.workspaces.stages;
import lombok.extern.slf4j.Slf4j;
import p.studio.compiler.lifecycle.LifecycleAssemblerService;
import p.studio.compiler.messages.BuildingIssueSink;
import p.studio.compiler.models.BuilderPipelineContext;
import p.studio.compiler.workspaces.PipelineStage;
import p.studio.utilities.logs.LogAggregator;
@Slf4j
public final class AssembleLifecyclePipelineStage implements PipelineStage {
private final LifecycleAssemblerService assembler;
public AssembleLifecyclePipelineStage() {
this(new LifecycleAssemblerService());
}
AssembleLifecyclePipelineStage(final LifecycleAssemblerService assembler) {
this.assembler = assembler;
}
@Override
public BuildingIssueSink run(final BuilderPipelineContext ctx, final LogAggregator logs) {
final var issues = BuildingIssueSink.empty();
final var assembled = assembler.assemble(ctx.irBackend, issues);
if (!issues.hasErrors()) {
ctx.irBackend = assembled;
logs.using(log).debug("Common lifecycle assembly completed successfully!");
}
return issues;
}
}
@@ -67,31 +67,31 @@ class LowerToIRVMServiceTest {
@Test
void lowerMustPublishSyntheticWrapperAtFunctionZeroAndKeepFinalRetInWrapperPath() {
final var backend = IRBackend.builder()
.entryPointCallableName("__pbs.frame_wrapper$m0")
.entryPointCallableName("__prometeu.lifecycle.frame_wrapper$m0")
.entryPointModuleId(new ModuleId(0))
.globals(ReadOnlyList.from(hiddenBootGuard(0)))
.syntheticFunctions(ReadOnlyList.from(new IRSyntheticFunction(
new ModuleId(0),
"__pbs.frame_wrapper$m0",
"__prometeu.lifecycle.frame_wrapper$m0",
IRSyntheticCallableKind.PUBLISHED_FRAME_WRAPPER,
new IRSyntheticOrigin(new FileId(0), "frame", new Span(new FileId(0), 1, 10)))))
.executableFunctions(ReadOnlyList.from(
fn("__pbs.file_init$f1", "app", 30, ReadOnlyList.from(ret())),
fn("__pbs.module_init$m0", "app", 31, ReadOnlyList.from(
callFunc("app", "__pbs.file_init$f1", 30),
fn("__prometeu.lifecycle.file_init$f1", "app", 30, ReadOnlyList.from(ret())),
fn("__prometeu.lifecycle.module_init$m0", "app", 31, ReadOnlyList.from(
callFunc("app", "__prometeu.lifecycle.file_init$f1", 30),
ret())),
fn("__pbs.project_init$m0", "app", 32, ReadOnlyList.from(
fn("__prometeu.lifecycle.project_init$m0", "app", 32, ReadOnlyList.from(
callFunc("app", "boot", 10),
ret())),
fn("boot", "app", 10, ReadOnlyList.from(ret())),
fn("frame", "app", 20, ReadOnlyList.from(ret())),
fn("__pbs.frame_wrapper$m0", "app", 40, ReadOnlyList.from(
fn("__prometeu.lifecycle.frame_wrapper$m0", "app", 40, ReadOnlyList.from(
getGlobal(0),
pushBool(true),
eq(),
jmpIfTrue("bootstrap_done"),
callFunc("app", "__pbs.module_init$m0", 31),
callFunc("app", "__pbs.project_init$m0", 32),
callFunc("app", "__prometeu.lifecycle.module_init$m0", 31),
callFunc("app", "__prometeu.lifecycle.project_init$m0", 32),
pushBool(true),
setGlobal(0),
label("bootstrap_done"),
@@ -101,7 +101,7 @@ class LowerToIRVMServiceTest {
final var lowered = new LowerToIRVMService().lower(backend);
assertEquals("__pbs.frame_wrapper$m0", lowered.module().functions().get(0).name());
assertEquals("__prometeu.lifecycle.frame_wrapper$m0", lowered.module().functions().get(0).name());
assertEquals(IRVMOp.GET_GLOBAL, lowered.module().functions().get(0).instructions().get(0).op());
assertEquals(IRVMOp.PUSH_BOOL, lowered.module().functions().get(0).instructions().get(1).op());
assertEquals(IRVMOp.EQ, lowered.module().functions().get(0).instructions().get(2).op());
@@ -124,12 +124,12 @@ class LowerToIRVMServiceTest {
@Test
void lowerMustRejectWhenSyntheticWrapperEntrypointIsMissing() {
final var backend = IRBackend.builder()
.entryPointCallableName("__pbs.frame_wrapper$m0")
.entryPointCallableName("__prometeu.lifecycle.frame_wrapper$m0")
.entryPointModuleId(new ModuleId(0))
.globals(ReadOnlyList.from(hiddenBootGuard(0)))
.syntheticFunctions(ReadOnlyList.from(new IRSyntheticFunction(
new ModuleId(0),
"__pbs.frame_wrapper$m0",
"__prometeu.lifecycle.frame_wrapper$m0",
IRSyntheticCallableKind.PUBLISHED_FRAME_WRAPPER,
new IRSyntheticOrigin(new FileId(0), "frame", new Span(new FileId(0), 1, 10)))))
.executableFunctions(ReadOnlyList.from(
@@ -148,11 +148,11 @@ class LowerToIRVMServiceTest {
.globals(ReadOnlyList.from(hiddenBootGuard(0)))
.syntheticFunctions(ReadOnlyList.from(new IRSyntheticFunction(
new ModuleId(0),
"__pbs.frame_wrapper$m0",
"__prometeu.lifecycle.frame_wrapper$m0",
IRSyntheticCallableKind.PUBLISHED_FRAME_WRAPPER,
new IRSyntheticOrigin(new FileId(0), "frame", new Span(new FileId(0), 1, 10)))))
.executableFunctions(ReadOnlyList.from(
fn("__pbs.frame_wrapper$m0", "app", 40, ReadOnlyList.from(
fn("__prometeu.lifecycle.frame_wrapper$m0", "app", 40, ReadOnlyList.from(
callFunc("app", "frame", 20),
ret())),
fn("frame", "app", 20, ReadOnlyList.from(ret()))))
@@ -165,15 +165,15 @@ class LowerToIRVMServiceTest {
@Test
void lowerMustRejectWhenHiddenBootGuardIsMissing() {
final var backend = IRBackend.builder()
.entryPointCallableName("__pbs.frame_wrapper$m0")
.entryPointCallableName("__prometeu.lifecycle.frame_wrapper$m0")
.entryPointModuleId(new ModuleId(0))
.syntheticFunctions(ReadOnlyList.from(new IRSyntheticFunction(
new ModuleId(0),
"__pbs.frame_wrapper$m0",
"__prometeu.lifecycle.frame_wrapper$m0",
IRSyntheticCallableKind.PUBLISHED_FRAME_WRAPPER,
new IRSyntheticOrigin(new FileId(0), "frame", new Span(new FileId(0), 1, 10)))))
.executableFunctions(ReadOnlyList.from(
fn("__pbs.frame_wrapper$m0", "app", 40, ReadOnlyList.from(
fn("__prometeu.lifecycle.frame_wrapper$m0", "app", 40, ReadOnlyList.from(
callFunc("app", "frame", 20),
ret())),
fn("frame", "app", 20, ReadOnlyList.from(ret()))))
@@ -186,16 +186,16 @@ class LowerToIRVMServiceTest {
@Test
void lowerMustRejectWhenSyntheticCallableOriginIsMissing() {
final var backend = IRBackend.builder()
.entryPointCallableName("__pbs.frame_wrapper$m0")
.entryPointCallableName("__prometeu.lifecycle.frame_wrapper$m0")
.entryPointModuleId(new ModuleId(0))
.globals(ReadOnlyList.from(userVisibleGlobal("__pbs.boot_guard$m0", 0)))
.globals(ReadOnlyList.from(userVisibleGlobal("__prometeu.lifecycle.boot_guard$m0", 0)))
.syntheticFunctions(ReadOnlyList.from(new IRSyntheticFunction(
new ModuleId(0),
"__pbs.frame_wrapper$m0",
"__prometeu.lifecycle.frame_wrapper$m0",
IRSyntheticCallableKind.PUBLISHED_FRAME_WRAPPER,
new IRSyntheticOrigin(new FileId(0), "", Span.none()))))
.executableFunctions(ReadOnlyList.from(
fn("__pbs.frame_wrapper$m0", "app", 40, ReadOnlyList.from(
fn("__prometeu.lifecycle.frame_wrapper$m0", "app", 40, ReadOnlyList.from(
callFunc("app", "frame", 20),
ret())),
fn("frame", "app", 20, ReadOnlyList.from(ret()))))
@@ -450,7 +450,7 @@ class LowerToIRVMServiceTest {
return new IRGlobal(
fileId,
ownerModuleId,
"__pbs.boot_guard$m" + moduleId,
"__prometeu.lifecycle.boot_guard$m" + moduleId,
"bool",
0,
IRGlobalVisibility.MODULE,
@@ -0,0 +1,367 @@
package p.studio.compiler.lifecycle;
import org.junit.jupiter.api.Test;
import p.studio.compiler.messages.BuildingIssueSink;
import p.studio.compiler.models.IRBackend;
import p.studio.compiler.models.IRBackendExecutableFunction;
import p.studio.compiler.models.IRGlobal;
import p.studio.compiler.models.IRGlobalOrigin;
import p.studio.compiler.models.IRGlobalVisibility;
import p.studio.compiler.models.IRHiddenGlobalKind;
import p.studio.compiler.models.IRLifecycleCallableReference;
import p.studio.compiler.models.IRLifecycleCallableRole;
import p.studio.compiler.models.IRLifecycleDeclaration;
import p.studio.compiler.models.IRLifecycleModuleDeclaration;
import p.studio.compiler.models.IRSyntheticCallableKind;
import p.studio.compiler.models.IRSyntheticFunction;
import p.studio.compiler.models.IRSyntheticOrigin;
import p.studio.compiler.source.Span;
import p.studio.compiler.source.identifiers.CallableId;
import p.studio.compiler.source.identifiers.FileId;
import p.studio.compiler.source.identifiers.ModuleId;
import p.studio.compiler.source.tables.CallableSignatureRef;
import p.studio.compiler.source.tables.ModuleReference;
import p.studio.utilities.structures.ReadOnlyList;
import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;
import static org.junit.jupiter.api.Assertions.*;
class LifecycleAssemblerServiceTest {
@Test
void assembleMustMaterializeNeutralLifecycleArtifactsInDeclaredOrder() {
final var backend = declarativeBackend();
final var issues = BuildingIssueSink.empty();
final var assembled = new LifecycleAssemblerService().assemble(backend, issues);
assertFalse(issues.hasErrors(), issues.asCollection().toString());
assertSame(backend.getLifecycleDeclaration(), assembled.getLifecycleDeclaration());
assertEquals("__prometeu.lifecycle.frame_wrapper$m1", assembled.getEntryPointCallableName());
assertEquals(1, assembled.getEntryPointModuleId().getIndex());
assertTrue(assembled.getSyntheticFunctions().stream().anyMatch(fn ->
fn.kind() == IRSyntheticCallableKind.MODULE_INIT
&& "__prometeu.lifecycle.module_init$m0".equals(fn.callableName())));
assertTrue(assembled.getSyntheticFunctions().stream().anyMatch(fn ->
fn.kind() == IRSyntheticCallableKind.PROJECT_INIT
&& "__prometeu.lifecycle.project_init$m1".equals(fn.callableName())));
assertTrue(assembled.getSyntheticFunctions().stream().anyMatch(fn ->
fn.kind() == IRSyntheticCallableKind.PUBLISHED_FRAME_WRAPPER
&& "__prometeu.lifecycle.frame_wrapper$m1".equals(fn.callableName())));
assertTrue(assembled.getGlobals().stream().anyMatch(global ->
global.hiddenKind() == IRHiddenGlobalKind.BOOT_GUARD
&& global.isHidden()
&& "__prometeu.lifecycle.boot_guard$m1".equals(global.name())));
assertTrue(assembled.getSyntheticFunctions().stream().noneMatch(fn ->
fn.callableName().contains("__pbs.")));
assertTrue(assembled.getGlobals().stream().noneMatch(global ->
global.name().contains("__pbs.")));
final var wrapper = executable(assembled, "__prometeu.lifecycle.frame_wrapper$m1");
final var calledNames = wrapper.instructions().stream()
.filter(instruction -> instruction.kind() == IRBackendExecutableFunction.InstructionKind.CALL_FUNC)
.map(IRBackendExecutableFunction.Instruction::calleeCallableName)
.toList();
assertEquals(
List.of(
"__prometeu.lifecycle.module_init$m0",
"__prometeu.lifecycle.module_init$m1",
"__prometeu.lifecycle.project_init$m1",
"frame"),
calledNames);
assertEquals(
1,
calledNames.stream().filter("__prometeu.lifecycle.project_init$m1"::equals).count());
assertEquals(IRBackendExecutableFunction.InstructionKind.RET, wrapper.instructions().getLast().kind());
final var moduleInit = executable(assembled, "__prometeu.lifecycle.module_init$m0");
assertEquals(
List.of("file_init_dep"),
moduleInit.instructions().stream()
.filter(instruction -> instruction.kind() == IRBackendExecutableFunction.InstructionKind.CALL_FUNC)
.map(IRBackendExecutableFunction.Instruction::calleeCallableName)
.toList());
final var hostModuleInit = executable(assembled, "__prometeu.lifecycle.module_init$m1");
assertEquals(
List.of("file_init_host"),
hostModuleInit.instructions().stream()
.filter(instruction -> instruction.kind() == IRBackendExecutableFunction.InstructionKind.CALL_FUNC)
.map(IRBackendExecutableFunction.Instruction::calleeCallableName)
.toList());
}
@Test
void assembleMustInvokeProjectInitExactlyOnceAndExcludeItFromFileInit() {
final var assembled = new LifecycleAssemblerService().assemble(declarativeBackend(), BuildingIssueSink.empty());
final var wrapperCalls = executable(assembled, assembled.getEntryPointCallableName()).instructions().stream()
.filter(instruction -> instruction.kind() == IRBackendExecutableFunction.InstructionKind.CALL_FUNC)
.map(IRBackendExecutableFunction.Instruction::calleeCallableName)
.toList();
final var fileInitCalls = executable(assembled, "file_init_host").instructions().stream()
.filter(instruction -> instruction.kind() == IRBackendExecutableFunction.InstructionKind.CALL_FUNC)
.map(IRBackendExecutableFunction.Instruction::calleeCallableName)
.toList();
assertEquals(1, wrapperCalls.stream().filter("__prometeu.lifecycle.project_init$m1"::equals).count());
assertTrue(wrapperCalls.contains("frame"));
assertTrue(fileInitCalls.stream().noneMatch("boot"::equals));
final var projectInitWrapper = executable(assembled, "__prometeu.lifecycle.project_init$m1");
assertEquals(
List.of("boot"),
projectInitWrapper.instructions().stream()
.filter(instruction -> instruction.kind() == IRBackendExecutableFunction.InstructionKind.CALL_FUNC)
.map(IRBackendExecutableFunction.Instruction::calleeCallableName)
.toList());
}
@Test
void assembleMustNoOpWhenLifecycleDeclarationIsAbsent() {
final var backend = IRBackend.builder()
.entryPointCallableName("main")
.entryPointModuleId(new ModuleId(0))
.executableFunctions(ReadOnlyList.from(fn("main", 0, 0, 0, span(1))))
.callableSignatures(ReadOnlyList.from(new CallableSignatureRef(new ModuleId(0), "main", 0, "() -> unit")))
.build();
final var issues = BuildingIssueSink.empty();
final var assembled = new LifecycleAssemblerService().assemble(backend, issues);
assertFalse(issues.hasErrors());
assertSame(backend, assembled);
assertNull(assembled.getLifecycleDeclaration());
assertTrue(assembled.getSyntheticFunctions().isEmpty());
}
@Test
void assembleMustRejectMissingFrameRootWithoutRepair() {
final var backend = backendWithDeclaration(new IRLifecycleDeclaration(
ReadOnlyList.from(new IRLifecycleModuleDeclaration(new ModuleId(0), ReadOnlyList.empty())),
null,
null));
final var issues = BuildingIssueSink.empty();
final var assembled = new LifecycleAssemblerService().assemble(backend, issues);
assertTrue(issues.hasErrors());
assertSame(backend, assembled);
assertEquals(LifecycleAssemblerService.INVALID_DECLARATION, firstCode(issues));
assertTrue(firstMessage(issues).contains("frame root"));
}
@Test
void assembleMustRejectUnresolvedCallableIds() {
final var backend = backendWithDeclaration(new IRLifecycleDeclaration(
ReadOnlyList.empty(),
null,
reference(0, 1, 99, IRLifecycleCallableRole.FRAME_ROOT, span(3))));
final var issues = BuildingIssueSink.empty();
new LifecycleAssemblerService().assemble(backend, issues);
assertTrue(issues.hasErrors());
assertTrue(firstMessage(issues).contains("unresolved lifecycle callable id"));
}
@Test
void assembleMustRejectIncompatibleRoles() {
final var backend = backendWithDeclaration(new IRLifecycleDeclaration(
ReadOnlyList.empty(),
null,
reference(0, 1, 2, IRLifecycleCallableRole.PROJECT_INIT, span(3))));
final var issues = BuildingIssueSink.empty();
new LifecycleAssemblerService().assemble(backend, issues);
assertTrue(issues.hasErrors());
assertTrue(firstMessage(issues).contains("incompatible lifecycle role"));
}
@Test
void assembleMustRejectMissingOrigin() {
final var backend = backendWithDeclaration(new IRLifecycleDeclaration(
ReadOnlyList.empty(),
null,
reference(0, 1, 2, IRLifecycleCallableRole.FRAME_ROOT, Span.none())));
final var issues = BuildingIssueSink.empty();
new LifecycleAssemblerService().assemble(backend, issues);
assertTrue(issues.hasErrors());
assertTrue(firstMessage(issues).contains("origin is missing"));
}
@Test
void assembleMustRejectPreMaterializedDerivedArtifacts() {
final var backend = declarativeBackend(new IRSyntheticFunction(
new ModuleId(1),
"already_wrapped",
IRSyntheticCallableKind.PUBLISHED_FRAME_WRAPPER,
new IRSyntheticOrigin(new FileId(2), "frame", span(2))));
final var issues = BuildingIssueSink.empty();
final var assembled = new LifecycleAssemblerService().assemble(backend, issues);
assertTrue(issues.hasErrors());
assertSame(backend, assembled);
assertTrue(firstMessage(issues).contains("pre-materialized lifecycle artifact"));
}
@Test
void assembleMustRejectDuplicateModuleContributions() {
final var module = new IRLifecycleModuleDeclaration(
new ModuleId(0),
ReadOnlyList.from(reference(0, 1, 0, IRLifecycleCallableRole.FILE_INIT_FRAGMENT, span(1))));
final var backend = backendWithDeclaration(new IRLifecycleDeclaration(
ReadOnlyList.from(module, module),
reference(1, 2, 3, IRLifecycleCallableRole.PROJECT_INIT, span(2)),
reference(1, 2, 2, IRLifecycleCallableRole.FRAME_ROOT, span(2))));
final var issues = BuildingIssueSink.empty();
new LifecycleAssemblerService().assemble(backend, issues);
assertTrue(issues.hasErrors());
assertTrue(firstMessage(issues).contains("duplicate lifecycle module"));
}
@Test
void assembleMustRejectNullBackend() {
final var issues = BuildingIssueSink.empty();
final var assembled = new LifecycleAssemblerService().assemble(null, issues);
assertNull(assembled);
assertTrue(issues.hasErrors());
assertEquals(LifecycleAssemblerService.PHASE, issues.asCollection().iterator().next().getPhase());
}
private static IRBackend declarativeBackend(final IRSyntheticFunction... extraSynthetics) {
return declarativeBackend(null, extraSynthetics);
}
private static IRBackend backendWithDeclaration(final IRLifecycleDeclaration declaration) {
return declarativeBackend(declaration);
}
private static IRBackend declarativeBackend(
final IRLifecycleDeclaration declarationOverride,
final IRSyntheticFunction... extraSynthetics) {
final var depSpan = span(1);
final var hostSpan = span(2);
final var synthetics = new ArrayList<IRSyntheticFunction>();
synthetics.add(new IRSyntheticFunction(
new ModuleId(0),
"file_init_dep",
IRSyntheticCallableKind.FILE_INIT_FRAGMENT,
new IRSyntheticOrigin(new FileId(1), "warmup", depSpan)));
synthetics.add(new IRSyntheticFunction(
new ModuleId(1),
"file_init_host",
IRSyntheticCallableKind.FILE_INIT_FRAGMENT,
new IRSyntheticOrigin(new FileId(2), "boot", hostSpan)));
synthetics.addAll(Arrays.asList(extraSynthetics));
final var declaration = declarationOverride != null
? declarationOverride
: new IRLifecycleDeclaration(
ReadOnlyList.from(
new IRLifecycleModuleDeclaration(
new ModuleId(0),
ReadOnlyList.from(reference(0, 1, 0, IRLifecycleCallableRole.FILE_INIT_FRAGMENT, depSpan))),
new IRLifecycleModuleDeclaration(
new ModuleId(1),
ReadOnlyList.from(reference(1, 2, 1, IRLifecycleCallableRole.FILE_INIT_FRAGMENT, hostSpan)))),
reference(1, 2, 3, IRLifecycleCallableRole.PROJECT_INIT, hostSpan),
reference(1, 2, 2, IRLifecycleCallableRole.FRAME_ROOT, hostSpan));
return IRBackend.builder()
.entryPointCallableName("frame")
.entryPointModuleId(new ModuleId(1))
.modulePool(ReadOnlyList.from(
new ModuleReference("app", ReadOnlyList.from("zzz")),
new ModuleReference("app", ReadOnlyList.from("aaa"))))
.callableSignatures(ReadOnlyList.from(
new CallableSignatureRef(new ModuleId(0), "file_init_dep", 0, "() -> unit"),
new CallableSignatureRef(new ModuleId(1), "file_init_host", 0, "() -> unit"),
new CallableSignatureRef(new ModuleId(1), "frame", 0, "() -> unit"),
new CallableSignatureRef(new ModuleId(1), "boot", 0, "() -> unit")))
.executableFunctions(ReadOnlyList.from(
fn("file_init_dep", 1, 0, 0, depSpan),
fn("file_init_host", 2, 1, 1, hostSpan),
fn("frame", 2, 1, 2, hostSpan),
fn("boot", 2, 1, 3, hostSpan)))
.syntheticFunctions(ReadOnlyList.wrap(synthetics))
.globals(ReadOnlyList.from(new IRGlobal(
new FileId(1),
new ModuleId(0),
"SCORE",
"int",
0,
IRGlobalVisibility.MODULE,
false,
IRHiddenGlobalKind.NONE,
new IRGlobalOrigin(new FileId(1), new ModuleId(0), "SCORE", depSpan, "SCORE"),
depSpan)))
.lifecycleDeclaration(declaration)
.build();
}
private static IRLifecycleCallableReference reference(
final int moduleId,
final int fileId,
final int callableId,
final IRLifecycleCallableRole role,
final Span origin) {
return new IRLifecycleCallableReference(
new ModuleId(moduleId),
new FileId(fileId),
new CallableId(callableId),
role,
origin);
}
private static IRBackendExecutableFunction fn(
final String name,
final int fileId,
final int moduleId,
final int callableId,
final Span span) {
return new IRBackendExecutableFunction(
new FileId(fileId),
new ModuleId(moduleId),
name,
new CallableId(callableId),
(int) span.getStart(),
(int) span.getEnd(),
0,
0,
0,
1,
ReadOnlyList.from(new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.RET,
"",
null,
null,
span)),
span);
}
private static IRBackendExecutableFunction executable(final IRBackend backend, final String name) {
return backend.getExecutableFunctions().stream()
.filter(function -> name.equals(function.callableName()))
.findFirst()
.orElseThrow(() -> new AssertionError("missing executable " + name));
}
private static Span span(final int fileId) {
return new Span(new FileId(fileId), 4, 16);
}
private static String firstCode(final BuildingIssueSink issues) {
return issues.asCollection().iterator().next().getCode();
}
private static String firstMessage(final BuildingIssueSink issues) {
return issues.asCollection().iterator().next().getMessage();
}
}
@@ -42,6 +42,9 @@ class BackendConformanceMatrixSpecTest {
"G20-4.2.1",
"G20-4.2.2",
"G20-4.2.3",
"G20-4.3.1",
"G20-4.3.2",
"G20-4.3.3",
"G20-6.2",
"G20-6.3",
"G20-6.4",
@@ -81,7 +84,11 @@ class BackendConformanceMatrixSpecTest {
"PBS13-12.3.2",
"PBS13-12.4.1",
"PBS13-12.4.2",
"PBS13-12.5");
"PBS13-12.5",
"PBS13-12.7",
"PBS13-12.8",
"PBS13-12.9",
"G23-5.2");
@Test
void matrixMustExistAndContainRequiredRequirementRows() throws IOException {
@@ -6,30 +6,53 @@ import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
class CommonBackendArchitectureTest {
private static final String BACKEND_SOURCE_ROOT =
"prometeu-compiler/prometeu-build-pipeline/src/main/java/p/studio/compiler/backend";
private static final String COMPILER_SOURCE_ROOT =
"prometeu-compiler/prometeu-build-pipeline/src/main/java/p/studio/compiler";
private static final List<String> GUARDED_RELATIVE_ROOTS = List.of(
"backend",
"lifecycle",
"workspaces/stages/AssembleLifecyclePipelineStage.java");
private static final String FORBIDDEN_PBS_PACKAGE = "p.studio.compiler.pbs";
private static final String FORBIDDEN_PBS_PREFIX = "__pbs.";
@Test
void commonBackendMustNotImportPbsFrontendPackages() throws IOException {
final var backendRoot = locateRepoRoot().resolve(BACKEND_SOURCE_ROOT);
final var violations = new ArrayList<String>();
try (final var paths = Files.walk(backendRoot)) {
paths.filter(path -> path.toString().endsWith(".java"))
.forEach(path -> assertNoPbsImport(path, violations));
}
walkGuardedSources(path -> assertNoPbsImport(path, violations));
assertTrue(
violations.isEmpty(),
"common backend must not import PBS frontend packages: " + violations);
}
@Test
void commonLifecycleAndBackendMustNotDiscoverRolesFromPbsNamePrefixes() throws IOException {
final var violations = new ArrayList<String>();
walkGuardedSources(path -> assertNoPbsPrefixMatching(path, violations));
assertTrue(
violations.isEmpty(),
"common lifecycle/backend code must not inspect __pbs. prefixes: " + violations);
}
private static void walkGuardedSources(final java.util.function.Consumer<Path> consumer) throws IOException {
final var compilerRoot = locateRepoRoot().resolve(COMPILER_SOURCE_ROOT);
for (final var relativeRoot : GUARDED_RELATIVE_ROOTS) {
final var root = compilerRoot.resolve(relativeRoot);
if (Files.isRegularFile(root)) {
consumer.accept(root);
continue;
}
try (final var paths = Files.walk(root)) {
paths.filter(path -> path.toString().endsWith(".java")).forEach(consumer);
}
}
}
private static void assertNoPbsImport(
final Path path,
final ArrayList<String> violations) {
@@ -44,6 +67,19 @@ class CommonBackendArchitectureTest {
}
}
private static void assertNoPbsPrefixMatching(
final Path path,
final ArrayList<String> violations) {
try {
final var content = Files.readString(path);
if (content.contains(FORBIDDEN_PBS_PREFIX)) {
violations.add(locateRepoRoot().relativize(path).toString());
}
} catch (IOException e) {
throw new IllegalStateException("failed to read source file: " + path, e);
}
}
private static Path locateRepoRoot() {
var cursor = Path.of(System.getProperty("user.dir")).toAbsolutePath().normalize();
while (cursor != null) {
@@ -0,0 +1,156 @@
package p.studio.compiler.workspaces;
import org.junit.jupiter.api.Test;
import p.studio.AppMode;
import p.studio.compiler.lifecycle.LifecycleAssemblerService;
import p.studio.compiler.messages.BuilderPipelineConfig;
import p.studio.compiler.models.BuilderPipelineContext;
import p.studio.compiler.models.IRBackend;
import p.studio.compiler.models.ResolvedWorkspace;
import p.studio.compiler.source.identifiers.ProjectId;
import p.studio.compiler.models.IRBackendExecutableFunction;
import p.studio.compiler.models.IRLifecycleCallableReference;
import p.studio.compiler.models.IRLifecycleCallableRole;
import p.studio.compiler.models.IRLifecycleDeclaration;
import p.studio.compiler.models.IRLifecycleModuleDeclaration;
import p.studio.compiler.models.IRSyntheticCallableKind;
import p.studio.compiler.source.Span;
import p.studio.compiler.source.identifiers.CallableId;
import p.studio.compiler.source.identifiers.FileId;
import p.studio.compiler.source.identifiers.ModuleId;
import p.studio.compiler.source.tables.CallableSignatureRef;
import p.studio.compiler.source.tables.ModuleReference;
import p.studio.compiler.workspaces.stages.AssembleLifecyclePipelineStage;
import p.studio.compiler.workspaces.stages.EmitBytecodePipelineStage;
import p.studio.compiler.workspaces.stages.FrontendPhasePipelineStage;
import p.studio.compiler.workspaces.stages.LinkBytecodePipelineStage;
import p.studio.compiler.workspaces.stages.LoadSourcesPipelineStage;
import p.studio.compiler.workspaces.stages.LowerToIRVMPipelineStage;
import p.studio.compiler.workspaces.stages.OptimizeIRVMPipelineStage;
import p.studio.compiler.workspaces.stages.ResolveDepsPipelineStage;
import p.studio.compiler.workspaces.stages.VerifyBytecodePipelineStage;
import p.studio.compiler.workspaces.stages.WriteBytecodeArtifactPipelineStage;
import p.studio.utilities.logs.LogAggregator;
import p.studio.utilities.structures.ReadOnlyList;
import java.lang.reflect.Field;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
class BuilderPipelineServiceOrderTest {
@Test
void canonicalOrderMustContainOptimizeBetweenLowerAndEmit() {
final var analyses = stageNames("analyses");
final var compile = stageNames("compile");
final var build = stageNames("build");
assertEquals(
List.of(
ResolveDepsPipelineStage.class.getSimpleName(),
LoadSourcesPipelineStage.class.getSimpleName(),
FrontendPhasePipelineStage.class.getSimpleName(),
AssembleLifecyclePipelineStage.class.getSimpleName()),
analyses);
assertEquals(
List.of(
LowerToIRVMPipelineStage.class.getSimpleName(),
OptimizeIRVMPipelineStage.class.getSimpleName(),
EmitBytecodePipelineStage.class.getSimpleName(),
LinkBytecodePipelineStage.class.getSimpleName(),
VerifyBytecodePipelineStage.class.getSimpleName()),
compile);
assertEquals(List.of(WriteBytecodeArtifactPipelineStage.class.getSimpleName()), build);
assertEquals(
FrontendPhasePipelineStage.class.getSimpleName(),
analyses.get(analyses.size() - 2));
assertEquals(
AssembleLifecyclePipelineStage.class.getSimpleName(),
analyses.getLast());
}
@Test
void analyzeMustTerminateAfterLifecycleAssemblyWithoutBackendArtifacts() {
final var ctx = BuilderPipelineContext.fromConfig(new BuilderPipelineConfig(false, "."));
ctx.irBackend = validDeclaration();
ctx.resolvedWorkspace = new ResolvedWorkspace(
new ProjectId(0),
null,
1,
AppMode.Game,
null,
null);
final var pipeline = new BuilderPipelineService(
List.of(new AssembleLifecyclePipelineStage()),
List.of(new LowerToIRVMPipelineStage()),
List.of());
final var snapshot = pipeline.analyze(ctx, LogAggregator.empty());
assertNotNull(snapshot.irBackend());
assertTrue(snapshot.irBackend().getSyntheticFunctions().stream().anyMatch(fn ->
fn.kind() == IRSyntheticCallableKind.PUBLISHED_FRAME_WRAPPER));
assertEquals(
"__prometeu.lifecycle.frame_wrapper$m0",
snapshot.irBackend().getEntryPointCallableName());
assertSame(ctx.irBackend.getLifecycleDeclaration(), snapshot.irBackend().getLifecycleDeclaration());
assertNull(ctx.irvm);
assertNull(ctx.optimizedIrvm);
assertNull(ctx.bytecodeModule);
assertNull(ctx.bytecodeBytes);
assertNull(ctx.bytecodeArtifactPath);
assertTrue(snapshot.diagnostics().stream().noneMatch(issue ->
LifecycleAssemblerService.INVALID_DECLARATION.equals(issue.getCode())));
}
@SuppressWarnings("unchecked")
private static List<String> stageNames(final String fieldName) {
try {
final Field field = BuilderPipelineService.class.getDeclaredField(fieldName);
field.setAccessible(true);
final var stages = (List<PipelineStage>) field.get(BuilderPipelineService.INSTANCE);
return stages.stream().map(stage -> stage.getClass().getSimpleName()).toList();
} catch (ReflectiveOperationException e) {
throw new AssertionError("failed to inspect pipeline field " + fieldName, e);
}
}
private static IRBackend validDeclaration() {
final var span = new Span(new FileId(1), 1, 8);
return IRBackend.builder()
.entryPointCallableName("frame")
.entryPointModuleId(new ModuleId(0))
.modulePool(ReadOnlyList.from(new ModuleReference("app", ReadOnlyList.from("main"))))
.callableSignatures(ReadOnlyList.from(
new CallableSignatureRef(new ModuleId(0), "frame", 0, "() -> unit")))
.executableFunctions(ReadOnlyList.from(new IRBackendExecutableFunction(
new FileId(1),
new ModuleId(0),
"frame",
new CallableId(0),
1,
8,
0,
0,
0,
1,
ReadOnlyList.from(new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.RET,
"",
null,
null,
span)),
span)))
.lifecycleDeclaration(new IRLifecycleDeclaration(
ReadOnlyList.from(new IRLifecycleModuleDeclaration(new ModuleId(0), ReadOnlyList.empty())),
null,
new IRLifecycleCallableReference(
new ModuleId(0),
new FileId(1),
new CallableId(0),
IRLifecycleCallableRole.FRAME_ROOT,
span)))
.build();
}
}
@@ -0,0 +1,131 @@
package p.studio.compiler.workspaces.stages;
import org.junit.jupiter.api.Test;
import p.studio.compiler.lifecycle.LifecycleAssemblerService;
import p.studio.compiler.messages.BuilderPipelineConfig;
import p.studio.compiler.messages.BuildingIssueSink;
import p.studio.compiler.models.BuilderPipelineContext;
import p.studio.compiler.models.IRBackend;
import p.studio.compiler.models.IRBackendExecutableFunction;
import p.studio.compiler.models.IRLifecycleCallableReference;
import p.studio.compiler.models.IRLifecycleCallableRole;
import p.studio.compiler.models.IRLifecycleDeclaration;
import p.studio.compiler.models.IRLifecycleModuleDeclaration;
import p.studio.compiler.models.IRSyntheticCallableKind;
import p.studio.compiler.source.Span;
import p.studio.compiler.source.identifiers.CallableId;
import p.studio.compiler.source.identifiers.FileId;
import p.studio.compiler.source.identifiers.ModuleId;
import p.studio.compiler.source.tables.CallableSignatureRef;
import p.studio.compiler.source.tables.ModuleReference;
import p.studio.utilities.logs.LogAggregator;
import p.studio.utilities.structures.ReadOnlyList;
import static org.junit.jupiter.api.Assertions.*;
class AssembleLifecyclePipelineStageTest {
@Test
void runMustAssignAssembledBackendOnSuccess() {
final var ctx = BuilderPipelineContext.fromConfig(new BuilderPipelineConfig(false, "."));
ctx.irBackend = validDeclaration();
final var original = ctx.irBackend;
final var issues = new AssembleLifecyclePipelineStage().run(ctx, LogAggregator.empty());
assertFalse(issues.hasErrors(), issues.asCollection().toString());
assertNotSame(original, ctx.irBackend);
assertTrue(ctx.irBackend.getSyntheticFunctions().stream().anyMatch(fn ->
fn.kind() == IRSyntheticCallableKind.PUBLISHED_FRAME_WRAPPER));
assertEquals(
original.getLifecycleDeclaration(),
ctx.irBackend.getLifecycleDeclaration());
assertNull(ctx.irvm);
assertNull(ctx.bytecodeModule);
assertNull(ctx.bytecodeBytes);
}
@Test
void runMustKeepOriginalBackendAndReportStructuralErrors() {
final var ctx = BuilderPipelineContext.fromConfig(new BuilderPipelineConfig(false, "."));
ctx.irBackend = IRBackend.builder()
.entryPointCallableName("frame")
.entryPointModuleId(new ModuleId(0))
.executableFunctions(ReadOnlyList.from(fn("frame", 0, 0)))
.callableSignatures(ReadOnlyList.from(new CallableSignatureRef(new ModuleId(0), "frame", 0, "() -> unit")))
.lifecycleDeclaration(new IRLifecycleDeclaration(ReadOnlyList.empty(), null, null))
.build();
final var original = ctx.irBackend;
final var issues = new AssembleLifecyclePipelineStage().run(ctx, LogAggregator.empty());
assertTrue(issues.hasErrors());
assertSame(original, ctx.irBackend);
assertEquals(LifecycleAssemblerService.INVALID_DECLARATION, issues.asCollection().iterator().next().getCode());
assertEquals(LifecycleAssemblerService.PHASE, issues.asCollection().iterator().next().getPhase());
assertNull(ctx.irvm);
}
@Test
void runMustNoOpForDeliberatelyNonExecutableHandoff() {
final var ctx = BuilderPipelineContext.fromConfig(new BuilderPipelineConfig(false, "."));
ctx.irBackend = IRBackend.builder()
.entryPointCallableName("main")
.entryPointModuleId(new ModuleId(0))
.executableFunctions(ReadOnlyList.from(fn("main", 0, 0)))
.build();
final var original = ctx.irBackend;
final var issues = new AssembleLifecyclePipelineStage().run(ctx, LogAggregator.empty());
assertFalse(issues.hasErrors());
assertSame(original, ctx.irBackend);
assertTrue(ctx.irBackend.getSyntheticFunctions().isEmpty());
}
private static IRBackend validDeclaration() {
final var span = new Span(new FileId(1), 1, 8);
return IRBackend.builder()
.entryPointCallableName("frame")
.entryPointModuleId(new ModuleId(0))
.modulePool(ReadOnlyList.from(new ModuleReference("app", ReadOnlyList.from("main"))))
.callableSignatures(ReadOnlyList.from(
new CallableSignatureRef(new ModuleId(0), "frame", 0, "() -> unit")))
.executableFunctions(ReadOnlyList.from(fn("frame", 0, 0)))
.lifecycleDeclaration(new IRLifecycleDeclaration(
ReadOnlyList.from(new IRLifecycleModuleDeclaration(new ModuleId(0), ReadOnlyList.empty())),
null,
new IRLifecycleCallableReference(
new ModuleId(0),
new FileId(1),
new CallableId(0),
IRLifecycleCallableRole.FRAME_ROOT,
span)))
.build();
}
private static IRBackendExecutableFunction fn(
final String name,
final int moduleId,
final int callableId) {
final var span = new Span(new FileId(1), 1, 8);
return new IRBackendExecutableFunction(
new FileId(1),
new ModuleId(moduleId),
name,
new CallableId(callableId),
1,
8,
0,
0,
0,
1,
ReadOnlyList.from(new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.RET,
"",
null,
null,
span)),
span);
}
}
@@ -34,6 +34,7 @@ public class IRBackend implements IRBackendReader {
private final ReadOnlyList<IntrinsicReference> intrinsicPool = ReadOnlyList.empty();
@Builder.Default
private final IRReservedMetadata reservedMetadata = IRReservedMetadata.empty();
private final IRLifecycleDeclaration lifecycleDeclaration;
public static IRBackendAggregator aggregator() {
return new IRBackendAggregator();
@@ -53,6 +54,8 @@ public class IRBackend implements IRBackendReader {
private final ArrayList<IRReservedMetadata.BuiltinTypeSurface> builtinTypeSurfaces = new ArrayList<>();
private final ArrayList<IRReservedMetadata.BuiltinConstSurface> builtinConstSurfaces = new ArrayList<>();
private final LinkedHashSet<String> requiredCapabilities = new LinkedHashSet<>();
private final ArrayList<IRLifecycleFileDeclaration> lifecycleFiles = new ArrayList<>();
private ReadOnlyList<ModuleId> lifecycleModuleOrder = ReadOnlyList.empty();
public void merge(final IRBackendFile backendFile) {
if (backendFile == null) {
@@ -90,6 +93,12 @@ public class IRBackend implements IRBackendReader {
for (final var function : backendFile.executableFunctions()) {
executableFunctions.add(remapExecutableFunction(function, moduleRemap, callableRemap, intrinsicRemap));
}
if (backendFile.lifecycleDeclaration() != null && !backendFile.lifecycleDeclaration().isEmpty()) {
lifecycleFiles.add(remapLifecycleFileDeclaration(
backendFile.lifecycleDeclaration(),
moduleRemap,
callableRemap));
}
final var metadata = backendFile.reservedMetadata();
hostMethodBindings.addAll(metadata.hostMethodBindings().asList());
builtinTypeSurfaces.addAll(metadata.builtinTypeSurfaces().asList());
@@ -111,6 +120,11 @@ public class IRBackend implements IRBackendReader {
return this;
}
public IRBackendAggregator lifecycleModuleOrder(final ReadOnlyList<ModuleId> moduleOrder) {
lifecycleModuleOrder = moduleOrder == null ? ReadOnlyList.empty() : moduleOrder;
return this;
}
private ModuleId[] reindexModules(final ReadOnlyList<ModuleReference> localModulePool) {
if (localModulePool == null || localModulePool.isEmpty()) {
return new ModuleId[0];
@@ -203,6 +217,37 @@ public class IRBackend implements IRBackendReader {
function.span());
}
private IRLifecycleFileDeclaration remapLifecycleFileDeclaration(
final IRLifecycleFileDeclaration declaration,
final ModuleId[] moduleRemap,
final CallableId[] callableRemap) {
final var remappedModuleId = remapModuleId(
declaration.moduleId(),
moduleRemap,
"lifecycle file");
return new IRLifecycleFileDeclaration(
remappedModuleId,
declaration.fileId(),
remapLifecycleCallable(declaration.fileInitFragment(), moduleRemap, callableRemap),
remapLifecycleCallable(declaration.projectInit(), moduleRemap, callableRemap),
remapLifecycleCallable(declaration.frameRoot(), moduleRemap, callableRemap));
}
private IRLifecycleCallableReference remapLifecycleCallable(
final IRLifecycleCallableReference reference,
final ModuleId[] moduleRemap,
final CallableId[] callableRemap) {
if (reference == null) {
return null;
}
return new IRLifecycleCallableReference(
remapModuleId(reference.moduleId(), moduleRemap, "lifecycle callable"),
reference.fileId(),
remapCallableId(reference.callableId(), callableRemap, "lifecycle callable"),
reference.role(),
reference.origin());
}
private ModuleId remapModuleId(
final ModuleId localModuleId,
final ModuleId[] moduleRemap,
@@ -273,6 +318,52 @@ public class IRBackend implements IRBackendReader {
return ReadOnlyList.wrap(pool);
}
private IRLifecycleDeclaration emitLifecycleDeclaration() {
if (lifecycleFiles.isEmpty()) {
return null;
}
if (lifecycleModuleOrder.isEmpty()) {
throw new IllegalStateException("lifecycle module order is required for executable handoff");
}
final var modules = new ArrayList<IRLifecycleModuleDeclaration>();
IRLifecycleCallableReference projectInit = null;
IRLifecycleCallableReference frameRoot = null;
for (final var moduleId : lifecycleModuleOrder) {
final var fragments = new ArrayList<IRLifecycleCallableReference>();
var hasLifecycleContribution = false;
for (final var lifecycleFile : lifecycleFiles) {
if (!sameModuleId(moduleId, lifecycleFile.moduleId())) {
continue;
}
hasLifecycleContribution = true;
if (lifecycleFile.fileInitFragment() != null) {
fragments.add(lifecycleFile.fileInitFragment());
}
if (projectInit == null && lifecycleFile.projectInit() != null) {
projectInit = lifecycleFile.projectInit();
}
if (frameRoot == null && lifecycleFile.frameRoot() != null) {
frameRoot = lifecycleFile.frameRoot();
}
}
if (hasLifecycleContribution) {
modules.add(new IRLifecycleModuleDeclaration(moduleId, ReadOnlyList.wrap(fragments)));
}
}
return new IRLifecycleDeclaration(ReadOnlyList.wrap(modules), projectInit, frameRoot);
}
private boolean sameModuleId(final ModuleId left, final ModuleId right) {
if (left == null || right == null) {
return left == right;
}
if (left.isNone() || right.isNone()) {
return left.isNone() && right.isNone();
}
return left.getIndex() == right.getIndex();
}
public IRBackend emit() {
return IRBackend
.builder()
@@ -290,6 +381,7 @@ public class IRBackend implements IRBackendReader {
ReadOnlyList.wrap(builtinTypeSurfaces),
ReadOnlyList.wrap(builtinConstSurfaces),
ReadOnlyList.wrap(requiredCapabilities.stream().toList())))
.lifecycleDeclaration(emitLifecycleDeclaration())
.build();
}
@@ -321,6 +413,7 @@ public class IRBackend implements IRBackendReader {
.append(", builtinTypes=").append(reservedMetadata.builtinTypeSurfaces().size())
.append(", builtinConsts=").append(reservedMetadata.builtinConstSurfaces().size())
.append(", requiredCapabilities=").append(reservedMetadata.requiredCapabilities().size())
.append(", lifecycle=").append(lifecycleDeclaration == null ? "none" : "declared")
.append('}');
if (functions.isEmpty()) {
@@ -17,7 +17,8 @@ public record IRBackendFile(
IRReservedMetadata reservedMetadata,
ReadOnlyList<ModuleReference> modulePool,
ReadOnlyList<CallableSignatureRef> callableSignatures,
ReadOnlyList<IntrinsicReference> intrinsicPool) {
ReadOnlyList<IntrinsicReference> intrinsicPool,
IRLifecycleFileDeclaration lifecycleDeclaration) {
public IRBackendFile {
fileId = Objects.requireNonNull(fileId, "fileId");
functions = functions == null ? ReadOnlyList.empty() : functions;
@@ -30,6 +31,29 @@ public record IRBackendFile(
intrinsicPool = intrinsicPool == null ? ReadOnlyList.empty() : intrinsicPool;
}
public IRBackendFile(
final FileId fileId,
final ReadOnlyList<IRFunction> functions,
final ReadOnlyList<IRSyntheticFunction> syntheticFunctions,
final ReadOnlyList<IRGlobal> globals,
final ReadOnlyList<IRBackendExecutableFunction> executableFunctions,
final IRReservedMetadata reservedMetadata,
final ReadOnlyList<ModuleReference> modulePool,
final ReadOnlyList<CallableSignatureRef> callableSignatures,
final ReadOnlyList<IntrinsicReference> intrinsicPool) {
this(
fileId,
functions,
syntheticFunctions,
globals,
executableFunctions,
reservedMetadata,
modulePool,
callableSignatures,
intrinsicPool,
null);
}
public IRBackendFile(
final FileId fileId,
final ReadOnlyList<IRFunction> functions) {
@@ -42,7 +66,8 @@ public record IRBackendFile(
IRReservedMetadata.empty(),
ReadOnlyList.empty(),
ReadOnlyList.empty(),
ReadOnlyList.empty());
ReadOnlyList.empty(),
null);
}
public static IRBackendFile empty(final FileId fileId) {
@@ -55,7 +80,8 @@ public record IRBackendFile(
IRReservedMetadata.empty(),
ReadOnlyList.empty(),
ReadOnlyList.empty(),
ReadOnlyList.empty());
ReadOnlyList.empty(),
null);
}
public IRBackendFile(
@@ -71,7 +97,8 @@ public record IRBackendFile(
reservedMetadata,
ReadOnlyList.empty(),
ReadOnlyList.empty(),
ReadOnlyList.empty());
ReadOnlyList.empty(),
null);
}
public IRBackendFile(
@@ -90,7 +117,8 @@ public record IRBackendFile(
reservedMetadata,
ReadOnlyList.empty(),
callableSignatures,
intrinsicPool);
intrinsicPool,
null);
}
public IRBackendFile(
@@ -110,6 +138,7 @@ public record IRBackendFile(
reservedMetadata,
modulePool,
callableSignatures,
intrinsicPool);
intrinsicPool,
null);
}
}
@@ -17,4 +17,5 @@ public interface IRBackendReader {
ReadOnlyList<CallableSignatureRef> getCallableSignatures();
ReadOnlyList<IntrinsicReference> getIntrinsicPool();
IRReservedMetadata getReservedMetadata();
IRLifecycleDeclaration getLifecycleDeclaration();
}
@@ -0,0 +1,23 @@
package p.studio.compiler.models;
import p.studio.compiler.source.Span;
import p.studio.compiler.source.identifiers.CallableId;
import p.studio.compiler.source.identifiers.FileId;
import p.studio.compiler.source.identifiers.ModuleId;
import java.util.Objects;
public record IRLifecycleCallableReference(
ModuleId moduleId,
FileId fileId,
CallableId callableId,
IRLifecycleCallableRole role,
Span origin) {
public IRLifecycleCallableReference {
moduleId = Objects.requireNonNull(moduleId, "moduleId");
fileId = Objects.requireNonNull(fileId, "fileId");
callableId = Objects.requireNonNull(callableId, "callableId");
role = Objects.requireNonNull(role, "role");
origin = origin == null ? Span.none() : origin;
}
}
@@ -0,0 +1,7 @@
package p.studio.compiler.models;
public enum IRLifecycleCallableRole {
FILE_INIT_FRAGMENT,
PROJECT_INIT,
FRAME_ROOT
}
@@ -0,0 +1,12 @@
package p.studio.compiler.models;
import p.studio.utilities.structures.ReadOnlyList;
public record IRLifecycleDeclaration(
ReadOnlyList<IRLifecycleModuleDeclaration> modules,
IRLifecycleCallableReference projectInit,
IRLifecycleCallableReference frameRoot) {
public IRLifecycleDeclaration {
modules = modules == null ? ReadOnlyList.empty() : modules;
}
}
@@ -0,0 +1,22 @@
package p.studio.compiler.models;
import p.studio.compiler.source.identifiers.FileId;
import p.studio.compiler.source.identifiers.ModuleId;
import java.util.Objects;
public record IRLifecycleFileDeclaration(
ModuleId moduleId,
FileId fileId,
IRLifecycleCallableReference fileInitFragment,
IRLifecycleCallableReference projectInit,
IRLifecycleCallableReference frameRoot) {
public IRLifecycleFileDeclaration {
moduleId = Objects.requireNonNull(moduleId, "moduleId");
fileId = Objects.requireNonNull(fileId, "fileId");
}
public boolean isEmpty() {
return fileInitFragment == null && projectInit == null && frameRoot == null;
}
}
@@ -0,0 +1,15 @@
package p.studio.compiler.models;
import p.studio.compiler.source.identifiers.ModuleId;
import p.studio.utilities.structures.ReadOnlyList;
import java.util.Objects;
public record IRLifecycleModuleDeclaration(
ModuleId moduleId,
ReadOnlyList<IRLifecycleCallableReference> fileInitFragments) {
public IRLifecycleModuleDeclaration {
moduleId = Objects.requireNonNull(moduleId, "moduleId");
fileInitFragments = fileInitFragments == null ? ReadOnlyList.empty() : fileInitFragments;
}
}
@@ -58,6 +58,11 @@ class IRBackendExecutableContractTest {
IRGlobalOrigin.class,
IRGlobalVisibility.class,
IRHiddenGlobalKind.class,
IRLifecycleDeclaration.class,
IRLifecycleModuleDeclaration.class,
IRLifecycleFileDeclaration.class,
IRLifecycleCallableReference.class,
IRLifecycleCallableRole.class,
IRReservedMetadata.class,
IRReservedMetadata.HostMethodBinding.class,
IRReservedMetadata.BuiltinTypeSurface.class,
@@ -80,7 +85,12 @@ class IRBackendExecutableContractTest {
IRReservedMetadata.class,
IRSyntheticCallableKind.class,
IRSyntheticFunction.class,
IRSyntheticOrigin.class);
IRSyntheticOrigin.class,
IRLifecycleDeclaration.class,
IRLifecycleModuleDeclaration.class,
IRLifecycleFileDeclaration.class,
IRLifecycleCallableReference.class,
IRLifecycleCallableRole.class);
assertTrue(
PUBLIC_CONTRACT_TYPES.containsAll(expectedTopLevelModelTypes),
@@ -137,6 +147,14 @@ class IRBackendExecutableContractTest {
assertEquals(FileId.class, recordComponentType(IRSyntheticOrigin.class, "fileId"));
assertEquals(ModuleId.class, recordComponentType(IRSyntheticFunction.class, "moduleId"));
assertEquals(ModuleId.class, recordComponentType(IRLifecycleModuleDeclaration.class, "moduleId"));
assertEquals(ModuleId.class, recordComponentType(IRLifecycleFileDeclaration.class, "moduleId"));
assertEquals(FileId.class, recordComponentType(IRLifecycleFileDeclaration.class, "fileId"));
assertEquals(ModuleId.class, recordComponentType(IRLifecycleCallableReference.class, "moduleId"));
assertEquals(FileId.class, recordComponentType(IRLifecycleCallableReference.class, "fileId"));
assertEquals(CallableId.class, recordComponentType(IRLifecycleCallableReference.class, "callableId"));
assertEquals(Span.class, recordComponentType(IRLifecycleCallableReference.class, "origin"));
assertEquals(String.class, recordComponentType(ModuleReference.class, "project"));
assertEquals(String.class, recordComponentType(CallableSignatureRef.class, "callableName"));
assertEquals(String.class, recordComponentType(IntrinsicReference.class, "canonicalName"));
@@ -640,6 +658,146 @@ class IRBackendExecutableContractTest {
second.getExecutableFunctions().get(1).callableId());
}
@Test
void aggregatorMustRemapTypedLifecycleReferencesAndPreserveDeclaredModuleOrder() {
final var fileASpan = new Span(new FileId(10), 1, 8);
final var fileBSpan = new Span(new FileId(20), 2, 9);
final var fileA = new IRBackendFile(
new FileId(10),
ReadOnlyList.empty(),
ReadOnlyList.from(new IRSyntheticFunction(
new ModuleId(0),
"file_init_zzz",
IRSyntheticCallableKind.FILE_INIT_FRAGMENT,
new IRSyntheticOrigin(new FileId(10), "warmup", fileASpan))),
ReadOnlyList.empty(),
ReadOnlyList.from(executable("file_init_zzz", 10, 0, 0, fileASpan)),
IRReservedMetadata.empty(),
ReadOnlyList.from(new ModuleReference("app", ReadOnlyList.from("zzz"))),
ReadOnlyList.from(new CallableSignatureRef(new ModuleId(0), "file_init_zzz", 0, "() -> unit")),
ReadOnlyList.empty(),
new IRLifecycleFileDeclaration(
new ModuleId(0),
new FileId(10),
new IRLifecycleCallableReference(
new ModuleId(0),
new FileId(10),
new CallableId(0),
IRLifecycleCallableRole.FILE_INIT_FRAGMENT,
fileASpan),
null,
null));
final var fileB = new IRBackendFile(
new FileId(20),
ReadOnlyList.empty(),
ReadOnlyList.empty(),
ReadOnlyList.empty(),
ReadOnlyList.from(
executable("boot", 20, 0, 0, fileBSpan),
executable("frame", 20, 0, 1, fileBSpan)),
IRReservedMetadata.empty(),
ReadOnlyList.from(new ModuleReference("app", ReadOnlyList.from("aaa"))),
ReadOnlyList.from(
new CallableSignatureRef(new ModuleId(0), "boot", 0, "() -> unit"),
new CallableSignatureRef(new ModuleId(0), "frame", 0, "() -> unit")),
ReadOnlyList.empty(),
new IRLifecycleFileDeclaration(
new ModuleId(0),
new FileId(20),
null,
new IRLifecycleCallableReference(
new ModuleId(0),
new FileId(20),
new CallableId(0),
IRLifecycleCallableRole.PROJECT_INIT,
fileBSpan),
new IRLifecycleCallableReference(
new ModuleId(0),
new FileId(20),
new CallableId(1),
IRLifecycleCallableRole.FRAME_ROOT,
fileBSpan)));
final var aggregator = IRBackend.aggregator();
aggregator.merge(fileA);
aggregator.merge(fileB);
aggregator.lifecycleModuleOrder(ReadOnlyList.from(new ModuleId(1), new ModuleId(0)));
final var backend = aggregator.emit();
final var declaration = backend.getLifecycleDeclaration();
assertNotNull(declaration);
assertEquals(2, declaration.modules().size());
assertEquals(1, declaration.modules().get(0).moduleId().getIndex());
assertEquals(0, declaration.modules().get(1).moduleId().getIndex());
assertEquals("aaa", backend.getModulePool().get(1).pathSegments().getFirst());
assertEquals("zzz", backend.getModulePool().get(0).pathSegments().getFirst());
assertEquals(IRLifecycleCallableRole.FILE_INIT_FRAGMENT, declaration.modules().get(1).fileInitFragments().getFirst().role());
assertEquals(0, declaration.modules().get(1).fileInitFragments().getFirst().callableId().getIndex());
assertEquals(1, declaration.projectInit().callableId().getIndex());
assertEquals(2, declaration.frameRoot().callableId().getIndex());
assertEquals(20, declaration.frameRoot().fileId().getId());
assertEquals(2, declaration.frameRoot().origin().getStart());
assertEquals("boot", backend.getExecutableFunctions().get(1).callableName());
assertEquals("frame", backend.getExecutableFunctions().get(2).callableName());
}
@Test
void aggregatorMustOmitLifecycleDeclarationWhenNoFileContributesOne() {
final var aggregator = IRBackend.aggregator();
aggregator.merge(new IRBackendFile(
new FileId(1),
ReadOnlyList.empty(),
ReadOnlyList.from(new IRBackendExecutableFunction(
new FileId(1),
"entry",
new CallableId(0),
0,
10,
0,
0,
0,
1,
ReadOnlyList.from(new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.RET,
"",
null,
null,
Span.none())),
Span.none())),
IRReservedMetadata.empty(),
ReadOnlyList.from(new CallableSignatureRef("entry", 0, "() -> unit")),
ReadOnlyList.empty()));
final var backend = aggregator.emit();
assertNull(backend.getLifecycleDeclaration());
}
private static IRBackendExecutableFunction executable(
final String name,
final int fileId,
final int moduleId,
final int callableId,
final Span span) {
return new IRBackendExecutableFunction(
new FileId(fileId),
new ModuleId(moduleId),
name,
new CallableId(callableId),
(int) span.getStart(),
(int) span.getEnd(),
0,
0,
0,
1,
ReadOnlyList.from(new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.RET,
"",
null,
null,
span)),
span);
}
private static IRBackend emitDeterministicAggregateFixture() {
final var aggregator = IRBackend.aggregator();
aggregator.merge(new IRBackendFile(