Implement DEC-0084 with factory-only Sprite/Animator structs, complete result lowering, validated animation sidecars, generated PBS factories and JavaFX/MCP authoring through shared services. Qualify native dev/release with ordinary and optimized producers, zero-allocation playback, private-cycle reclamation, canonical Composer pixels, installed JARs and JavaFX lifecycle. Preserve the runtime checkout and existing host ABI.
292 lines
19 KiB
Java
292 lines
19 KiB
Java
package p.studio.app.compiler;
|
|
|
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
|
import p.studio.api.automation.AutomationException;
|
|
import p.studio.api.automation.AutomationFailure;
|
|
import p.studio.api.automation.ProjectKnowledge;
|
|
import p.studio.api.project.ProjectCatalog;
|
|
import p.studio.api.project.ProjectReference;
|
|
import p.studio.compiler.FrontendRegistryService;
|
|
import p.studio.compiler.dtos.PrometeuManifestDTO;
|
|
import p.studio.compiler.messages.BuildingIssueSink;
|
|
import p.studio.compiler.workspaces.phases.DependencyResolver;
|
|
import p.studio.core.project.ProjectAccessRegistry;
|
|
import p.studio.lsp.messages.LspProjectContext;
|
|
import p.studio.lsp.services.compiler.CompilerLanguageServiceBridge;
|
|
|
|
import java.io.IOException;
|
|
import java.nio.file.Path;
|
|
import java.util.*;
|
|
|
|
/** Read-only manifest/provider discovery. Never selects a default frontend or starts a build. */
|
|
public final class CompilerProjectKnowledge implements ProjectKnowledge {
|
|
private record OwnedReference(String owner, p.studio.compiler.services.FrontendReferenceProvider.Reference reference) {}
|
|
private record Discovery(Context context, Map<String, OwnedReference> references) {}
|
|
private static final int MAX_PROJECTS = 256;
|
|
private final ProjectAccessRegistry openProjects;
|
|
private final ProjectCatalog projects;
|
|
private final ObjectMapper mapper;
|
|
private final CompilerLanguageServiceBridge languageBridge;
|
|
|
|
public CompilerProjectKnowledge(ProjectAccessRegistry openProjects, ProjectCatalog projects, ObjectMapper mapper) {
|
|
this(openProjects,projects,mapper,null);
|
|
}
|
|
public CompilerProjectKnowledge(ProjectAccessRegistry openProjects,ProjectCatalog projects,ObjectMapper mapper,p.animation.GlyphBankLayoutSource layouts) {
|
|
this.languageBridge=new CompilerLanguageServiceBridge(layouts);
|
|
this.openProjects = Objects.requireNonNull(openProjects);
|
|
this.projects = Objects.requireNonNull(projects);
|
|
this.mapper = Objects.requireNonNull(mapper);
|
|
}
|
|
|
|
@Override public Context context(Path openProjectRoot) {
|
|
return discover(openProjectRoot).context();
|
|
}
|
|
|
|
private Discovery discover(Path openProjectRoot) {
|
|
Path root = openProjects.requireOpenRoot(openProjectRoot);
|
|
var limitations = new ArrayList<String>();
|
|
var discovered = new LinkedHashMap<Path, ProjectReference>();
|
|
var dependencies = new LinkedHashMap<Path, List<Path>>();
|
|
var readOnly = new LinkedHashSet<Path>();
|
|
var unresolved = new ArrayList<Library>();
|
|
var pending = new ArrayDeque<Path>();
|
|
var visited = new HashSet<Path>();
|
|
pending.add(root);
|
|
boolean dependenciesComplete = true;
|
|
while (!pending.isEmpty()) {
|
|
Path current = pending.removeFirst();
|
|
if (!visited.add(current)) continue;
|
|
if (visited.size() > MAX_PROJECTS)
|
|
throw new AutomationException(AutomationFailure.Code.LIMIT_EXCEEDED, "Project graph exceeds " + MAX_PROJECTS + " projects");
|
|
ProjectReference project;
|
|
PrometeuManifestDTO manifest;
|
|
try {
|
|
project = projects.openProject(current);
|
|
manifest = mapper.readValue(current.resolve("prometeu.json").toFile(), PrometeuManifestDTO.class);
|
|
} catch (IOException | RuntimeException failure) {
|
|
if (current.equals(root))
|
|
throw new AutomationException(AutomationFailure.Code.INFRASTRUCTURE_FAILURE, "Cannot read the current project manifest");
|
|
dependenciesComplete = false;
|
|
limitations.add("Dependency manifest unavailable: " + current);
|
|
unresolved.add(new Library(current.toString(), Version.unknown(), List.of(current), false));
|
|
readOnly.add(current);
|
|
dependencies.put(current, List.of());
|
|
continue;
|
|
}
|
|
discovered.put(current, project);
|
|
var children = new ArrayList<Path>();
|
|
dependencies.put(current, children);
|
|
if (manifest.dependencies() == null) continue;
|
|
if (manifest.dependencies().size() > MAX_PROJECTS)
|
|
throw new AutomationException(AutomationFailure.Code.LIMIT_EXCEEDED, "Too many dependency declarations");
|
|
for (var declaration : manifest.dependencies()) {
|
|
if (declaration == null
|
|
|| declaration instanceof PrometeuManifestDTO.DependencyDeclaration.Local local
|
|
&& (local.path() == null || local.path().isBlank())
|
|
|| declaration instanceof PrometeuManifestDTO.DependencyDeclaration.Registry registry
|
|
&& (registry.name() == null || registry.name().isBlank() || registry.version() == null || registry.version().isBlank()))
|
|
throw new AutomationException(AutomationFailure.Code.INFRASTRUCTURE_FAILURE, "Invalid dependency declaration in " + current);
|
|
var issues = BuildingIssueSink.empty();
|
|
// The compiler resolves even transitive local paths and registry entries against the main root.
|
|
var resolved = DependencyResolver.resolveDependencies(root, List.of(declaration), issues);
|
|
if (issues.hasErrors() || resolved.isEmpty()) {
|
|
dependenciesComplete = false;
|
|
String id = declaration instanceof PrometeuManifestDTO.DependencyDeclaration.Registry registry
|
|
? registry.name() + "@" + registry.version()
|
|
: String.valueOf(((PrometeuManifestDTO.DependencyDeclaration.Local) declaration).path());
|
|
var version = declaration instanceof PrometeuManifestDTO.DependencyDeclaration.Registry registry
|
|
&& registry.version() != null && !registry.version().isBlank()
|
|
? new Version(registry.version(), current.resolve("prometeu.json") + "#dependencies (requested)") : Version.unknown();
|
|
unresolved.add(new Library(id, version, List.of(), false));
|
|
limitations.add("Dependency could not be resolved by the compiler: " + id + " (declared by " + current + ")");
|
|
continue;
|
|
}
|
|
Path child = resolved.getFirst().canonPath();
|
|
children.add(child);
|
|
if (!child.startsWith(root) || declaration instanceof PrometeuManifestDTO.DependencyDeclaration.Registry)
|
|
readOnly.add(child);
|
|
pending.add(child);
|
|
}
|
|
}
|
|
// Read-only provenance wins if a library is reachable through more than one declaration.
|
|
boolean changed;
|
|
do {
|
|
changed = false;
|
|
for (var edge : dependencies.entrySet())
|
|
if (readOnly.stream().anyMatch(edge.getKey()::startsWith))
|
|
changed |= readOnly.addAll(edge.getValue());
|
|
} while (changed);
|
|
|
|
var protectedSources = new LinkedHashSet<Path>();
|
|
for (var project : discovered.values()) {
|
|
if (readOnly.stream().anyMatch(project.rootPath()::startsWith))
|
|
FrontendRegistryService.getProvider(project.languageId()).ifPresent(provider ->
|
|
provider.specification().getSourceRoots().forEach(relative ->
|
|
protectedSources.add(canonical(project.rootPath().resolve(relative)))));
|
|
}
|
|
readOnly.addAll(protectedSources);
|
|
|
|
var libraries = new ArrayList<Library>();
|
|
var byLanguage = new LinkedHashMap<String, List<ProjectReference>>();
|
|
for (var entry : discovered.entrySet()) {
|
|
var project = entry.getValue();
|
|
byLanguage.computeIfAbsent(project.languageId(), ignored -> new ArrayList<>()).add(project);
|
|
if (!entry.getKey().equals(root)) {
|
|
boolean editable = entry.getKey().startsWith(root) && readOnly.stream().noneMatch(entry.getKey()::startsWith);
|
|
libraries.add(new Library(project.name(), new Version(project.version(), entry.getKey().resolve("prometeu.json") + "#version"),
|
|
List.of(entry.getKey()), editable));
|
|
}
|
|
}
|
|
libraries.addAll(unresolved);
|
|
var references = new LinkedHashMap<String, OwnedReference>();
|
|
discovered.values().forEach(project -> collectReferences(project, references, limitations));
|
|
var languages = new ArrayList<Language>();
|
|
String primary = discovered.get(root).languageId();
|
|
if (byLanguage.size() > 1) limitations.add("The installed build pipeline requires the same language across the dependency graph");
|
|
for (var entry : byLanguage.entrySet()) {
|
|
var language = language(entry.getKey(), entry.getValue(), primary.equals(entry.getKey()),
|
|
dependenciesComplete && byLanguage.size() == 1, limitations,
|
|
references.entrySet().stream().filter(ref -> ref.getValue().owner().equals(entry.getKey())).map(Map.Entry::getKey).toList());
|
|
languages.add(language);
|
|
for (Path source : language.sourceRoots()) if (!source.startsWith(root)) readOnly.add(source);
|
|
for (var project : entry.getValue()) {
|
|
var sdk = new Library("sdk:" + entry.getKey() + ":" + project.stdlibVersion(),
|
|
new Version(Integer.toString(project.stdlibVersion()), project.rootPath().resolve("prometeu.json") + "#stdlib (requested)"),
|
|
List.of(), false);
|
|
if (libraries.stream().noneMatch(item -> item.id().equals(sdk.id()))) libraries.add(sdk);
|
|
}
|
|
}
|
|
limitations.add("SDK resources are provider-owned, read-only resources, not editable project files");
|
|
limitations.add("Virtual SDK symbols may have no physical LSP definition location; consult indexed SDK references");
|
|
// Closing a project during discovery must not publish a successful context for that closed project.
|
|
openProjects.requireOpenRoot(root);
|
|
var descriptors = references.values().stream().map(owned -> {
|
|
var ref = owned.reference();
|
|
return new Reference(ref.id(), ref.title(), owned.owner(), ReferenceKind.valueOf(ref.kind().name()),
|
|
new Version(ref.version(), ref.versionSource()));
|
|
}).toList();
|
|
return new Discovery(new Context(root, discovered.get(root).name(), languages, libraries,
|
|
List.of(root), List.copyOf(readOnly), descriptors, limitations.stream().distinct().toList()), Map.copyOf(references));
|
|
}
|
|
|
|
private Language language(String id, List<ProjectReference> projects, boolean primary,
|
|
boolean graphBuildable, List<String> limitations, List<String> referenceIds) {
|
|
var sdkVersions = projects.stream().map(ProjectReference::stdlibVersion).distinct().toList();
|
|
Version sdk = sdkVersions.size() == 1
|
|
? new Version(sdkVersions.getFirst().toString(), "prometeu.json#stdlib (requested)") : Version.unknown();
|
|
if (sdkVersions.size() != 1) limitations.add("Multiple SDK versions requested for " + id + ": " + sdkVersions);
|
|
var provider = FrontendRegistryService.getProvider(id);
|
|
if (provider.isEmpty()) {
|
|
limitations.add("UNSUPPORTED_LANGUAGE: no installed frontend for " + id);
|
|
return new Language(id, primary, Version.unknown(), Version.unknown(), sdk, List.of(), List.of(),
|
|
List.of(capability("build", false), capability("lsp", false)), referenceIds);
|
|
}
|
|
var spec = provider.get().specification();
|
|
var roots = new LinkedHashSet<Path>();
|
|
projects.forEach(project -> spec.getSourceRoots().forEach(relative -> roots.add(canonical(project.rootPath().resolve(relative)))));
|
|
boolean sdkSupported = sdkVersions.stream().allMatch(version -> spec.getStdlibVersions().stream().anyMatch(item -> item.version() == version));
|
|
if (!sdkSupported) limitations.add("Unsupported requested SDK version for " + id + ": " + sdkVersions);
|
|
if (sdkSupported && sdk.known()) sdk = new Version(sdk.value(), "prometeu.json#stdlib; supported by installed frontend");
|
|
var capabilities = new ArrayList<Capability>();
|
|
capabilities.add(capability("build", graphBuildable && sdkSupported));
|
|
var project = projects.getFirst();
|
|
addLspCapabilities(id, project, capabilities, limitations);
|
|
String compilerVersion = provider.get().getClass().getPackage().getImplementationVersion();
|
|
return new Language(id, primary, Version.unknown(), compilerVersion == null || compilerVersion.isBlank()
|
|
? Version.unknown() : new Version(compilerVersion, "installed frontend package Implementation-Version"), sdk,
|
|
spec.getAllowedExtensions().stream().sorted().toList(), List.copyOf(roots), capabilities, referenceIds);
|
|
}
|
|
|
|
private void collectReferences(ProjectReference project, Map<String, OwnedReference> references, List<String> limitations) {
|
|
String owner = project.languageId();
|
|
String selection = owner + " / " + project.target() + " / SDK " + project.stdlibVersion();
|
|
try {
|
|
var documentation = FrontendRegistryService.getProvider(owner).flatMap(p.studio.compiler.services.FrontendProvider::documentation);
|
|
if (documentation.isEmpty()) {
|
|
limitations.add("DOCUMENTATION_UNAVAILABLE: no installed reference provider for " + owner);
|
|
return;
|
|
}
|
|
var selected = documentation.get().references(project.stdlibVersion(), p.studio.AppMode.valueOf(project.target().name()));
|
|
var additions = new LinkedHashMap<String, OwnedReference>();
|
|
for (var reference : selected) {
|
|
var owned = new OwnedReference(owner, reference);
|
|
if (!reference.id().startsWith(owner + ":")
|
|
|| references.containsKey(reference.id()) && !references.get(reference.id()).equals(owned)
|
|
|| additions.putIfAbsent(reference.id(), owned) != null)
|
|
throw new IllegalStateException("Ambiguous or invalid reference ID");
|
|
}
|
|
references.putAll(additions);
|
|
if (selected.isEmpty()) limitations.add("DOCUMENTATION_UNAVAILABLE: no installed references for " + selection);
|
|
if (selected.stream().noneMatch(ref -> ref.kind() == p.studio.compiler.services.FrontendReferenceProvider.Kind.SDK
|
|
&& Integer.toString(project.stdlibVersion()).equals(ref.version())))
|
|
limitations.add("DOCUMENTATION_UNAVAILABLE: no installed SDK reference for " + selection);
|
|
} catch (RuntimeException unavailable) {
|
|
limitations.add("DOCUMENTATION_UNAVAILABLE: cannot load installed references for " + selection);
|
|
}
|
|
}
|
|
|
|
private void addLspCapabilities(String id, ProjectReference project, List<Capability> capabilities, List<String> limitations) {
|
|
final p.studio.lsp.messages.BaselineServerDescription server;
|
|
try {
|
|
server = languageBridge.describeServer(new LspProjectContext(project.rootPath().toString(), id, project.rootPath()));
|
|
} catch (RuntimeException unavailable) {
|
|
String reason = "Installed frontend cannot describe LSP capabilities for " + id;
|
|
capabilities.add(new Capability("lsp", Support.UNKNOWN, reason));
|
|
limitations.add(reason);
|
|
return;
|
|
}
|
|
capabilities.add(capability("lsp", true));
|
|
capabilities.add(capability("diagnostics", true));
|
|
capabilities.add(capability("semanticTokens", true));
|
|
capabilities.add(capability("hover", server.hoverSupported()));
|
|
capabilities.add(capability("completion", server.completionSupported()));
|
|
capabilities.add(capability("signatureHelp", server.signatureHelpSupported()));
|
|
capabilities.add(capability("definition", server.definitionSupported()));
|
|
capabilities.add(capability("references", server.referencesSupported()));
|
|
capabilities.add(capability("documentSymbols", server.documentSymbolsSupported()));
|
|
capabilities.add(capability("workspaceSymbols", server.workspaceSymbolsSupported()));
|
|
capabilities.add(capability("rename", server.renameSupported()));
|
|
capabilities.add(capability("codeActions", server.codeActionsSupported()));
|
|
capabilities.add(capability("documentLinks", server.documentLinksSupported()));
|
|
capabilities.add(capability("foldingRanges", server.foldingRangesSupported()));
|
|
capabilities.add(capability("selectionRanges", server.selectionRangesSupported()));
|
|
capabilities.add(capability("formatting", server.formattingSupported()));
|
|
capabilities.add(capability("callHierarchy", server.callHierarchySupported()));
|
|
capabilities.add(capability("typeHierarchy", false));
|
|
}
|
|
|
|
private static Capability capability(String name, boolean supported) {
|
|
return new Capability(name, supported ? Support.SUPPORTED : Support.UNSUPPORTED,
|
|
supported ? null : "Not supported by the installed provider or current project dependency/SDK configuration");
|
|
}
|
|
|
|
private static Path canonical(Path path) {
|
|
Path normalized = path.toAbsolutePath().normalize();
|
|
try { return normalized.toRealPath(); }
|
|
catch (IOException ignored) {
|
|
Path parent = normalized.getParent();
|
|
return parent == null ? normalized : canonical(parent).resolve(normalized.getFileName());
|
|
}
|
|
}
|
|
|
|
@Override public ReferencePage readReference(Path openProjectRoot, String referenceId, int offset, int limit) {
|
|
openProjects.requireOpenRoot(openProjectRoot);
|
|
if (referenceId == null || referenceId.isBlank() || offset < 0 || limit < 1 || limit > 16000)
|
|
throw new IllegalArgumentException("Invalid reference ID or pagination");
|
|
var discovery = discover(openProjectRoot);
|
|
var reference = discovery.references().get(referenceId);
|
|
if (reference == null) {
|
|
var primary = discovery.context().languages().stream().filter(Language::primary).findFirst().orElseThrow();
|
|
var code = FrontendRegistryService.getProvider(primary.id()).isEmpty() ? AutomationFailure.Code.UNSUPPORTED_LANGUAGE
|
|
: discovery.references().isEmpty() ? AutomationFailure.Code.DOCUMENTATION_UNAVAILABLE : AutomationFailure.Code.REFERENCE_NOT_FOUND;
|
|
throw new AutomationException(code, "Reference is not available in this project's installed index");
|
|
}
|
|
String text = reference.reference().text();
|
|
int total = text.codePointCount(0, text.length());
|
|
if (offset > total) throw new IllegalArgumentException("Reference offset exceeds its length");
|
|
int next = offset + Math.min(limit, total - offset);
|
|
String page = text.substring(text.offsetByCodePoints(0, offset), text.offsetByCodePoints(0, next));
|
|
return new ReferencePage(referenceId, offset, total, next == total ? null : next, page);
|
|
}
|
|
}
|