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
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:
+76
-47
@@ -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;
|
||||
|
||||
+47
-424
@@ -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();
|
||||
|
||||
+5
-4
@@ -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) {
|
||||
|
||||
+8
-4
@@ -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(
|
||||
|
||||
+14
-5
@@ -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
|
||||
|
||||
+102
-33
@@ -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
|
||||
|
||||
+2
@@ -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;
|
||||
}
|
||||
|
||||
+532
@@ -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;
|
||||
}
|
||||
}
|
||||
+2
-1
@@ -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(
|
||||
|
||||
+32
@@ -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;
|
||||
}
|
||||
}
|
||||
+22
-22
@@ -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,
|
||||
|
||||
+367
@@ -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();
|
||||
}
|
||||
}
|
||||
+8
-1
@@ -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 {
|
||||
|
||||
+45
-9
@@ -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) {
|
||||
|
||||
+156
@@ -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();
|
||||
}
|
||||
}
|
||||
+131
@@ -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);
|
||||
}
|
||||
}
|
||||
+93
@@ -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()) {
|
||||
|
||||
+35
-6
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
+1
@@ -17,4 +17,5 @@ public interface IRBackendReader {
|
||||
ReadOnlyList<CallableSignatureRef> getCallableSignatures();
|
||||
ReadOnlyList<IntrinsicReference> getIntrinsicPool();
|
||||
IRReservedMetadata getReservedMetadata();
|
||||
IRLifecycleDeclaration getLifecycleDeclaration();
|
||||
}
|
||||
|
||||
+23
@@ -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;
|
||||
}
|
||||
}
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
package p.studio.compiler.models;
|
||||
|
||||
public enum IRLifecycleCallableRole {
|
||||
FILE_INIT_FRAGMENT,
|
||||
PROJECT_INIT,
|
||||
FRAME_ROOT
|
||||
}
|
||||
+12
@@ -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;
|
||||
}
|
||||
}
|
||||
+22
@@ -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;
|
||||
}
|
||||
}
|
||||
+15
@@ -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;
|
||||
}
|
||||
}
|
||||
+159
-1
@@ -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(
|
||||
|
||||
Reference in New Issue
Block a user