feat(pbs): add service constants and runtime math integration

This commit is contained in:
2026-10-17 11:21:58 +01:00
parent 2a418085d2
commit d1e9259085
32 changed files with 1117 additions and 40 deletions
@@ -0,0 +1,160 @@
---
id: LSN-0085
ticket: pbs-runtime-math-integration
title: Service constants and source-to-runtime math conformance
created: 2026-10-17
tags: [runtime-integration]
---
## Original problem and ownership
Owner: compiler/pbs. Supporting contract: compiler/general; runtime numeric
semantics remain owned by the VM. This lesson consolidates accepted DEC-0069
and implemented PLN-0148 from AGD-0083 / DSC-0081.
The common compiler already represented all runtime math identities and canonical
constants. That did not make them usable from PBS source. The remaining work was
service syntax, exact overload resolution, SDK publication, constant reads and
source-to-production execution evidence.
## Consolidated decision
The user explicitly chose services themselves as namespaces. Services export
constants alongside methods; there is no separate namespace declaration or new
numeric builtin type. The same capability applies to project and SDK services.
`math` exposes exact int/long overloads and `mathf` exposes Float functions.
Conversions between numeric carriers are explicit. The compiler consumes its
existing manually ported, independently checked common catalog. It does not query
a runtime checkout during normal compilation or duplicate the VM's math backend.
Pi and tau use canonical builtin constant materialization, not zero-argument
intrinsics. Mathematical calls retain their faults and costs even with literal
arguments. Qualification must start with source and compare exact bits, faults
and cycles on a named runtime build.
## Final implementation
The service AST retains constant declarations with their owner. Parser, declaration
checks, dependency/cycle validation, type resolution, lowering and editor member
surfaces carry them through. Constants are immutable, exported with their service,
and available through qualified reads and import aliases. Within the owner, a
constant reference takes precedence over a same-named global; locals retain their
normal lexical precedence. Explicit long annotations contextually type integer
constant literals, without converting references to already typed int constants.
SDK services at `@sdk:math` and `@sdk:mathf` bind their 26 exact signatures through
reserved IntrinsicCall metadata. Each generated callable loads its declared
arguments, calls the common catalog identity and returns. Consequently its normal
CALL/GET_LOCAL/RET overhead is distinct from the intrinsic's own charge. Imports
with aliases resolve to the original provider callable identity.
BuiltinConst metadata on service constants records the qualified source name.
The existing BUILTIN_CONST instruction materializes `IRVMBuiltinConstantDefinition`.
Pi and tau retain bits `0x400921FB54442D18` and `0x401921FB54442D18`. A qualified
constant read does not construct a singleton or call a getter. Constant-only
probes cost six cycles: an ordinary load plus the root return.
```pbs
import { math } from @sdk:math;
import { mathf as numbers } from @sdk:mathf;
fn example(counter: long, angle: float) -> float {
let bounded = math.clamp(counter, 0 as long, 100 as long);
return math.to_float(bounded) + numbers.sin(angle) + numbers.pi;
}
```
General service constants use ordinary source expressions:
```pbs
declare service Settings {
declare const base: int = 40;
declare const answer: int = base + 2;
fn read() -> int { return answer; }
}
```
## Qualification and reproducibility
Runtime revision: `f7d7c167531bb662a1af9d73fc326bb476bf8aa7`, unchanged clean checkout.
Platform: macOS 27.0.1 arm64. Production harness profiles: dev and release;
VM feature: resource-diagnostics, default load limits, NONE capabilities for math.
Java build uses JDK 25; installed launcher uses the existing distribution runtime.
The corpus contains 261 independent numeric cases, emitted both normally and with
the PBS/common optimizer enabled: 522 mandatory cases in each runtime profile.
It combines the first 240 scalar provider fixture rows with exact published
contract examples, removing duplicates. It covers all 26 signatures, signed zeros,
subnormals, finite extrema, checked conversions, ties-to-even, invalid clamp,
negative sqrt, abs(MIN) and atan2 axes. Additional probes cover pi/tau, direct
literal sin, ordinary int/long constants, dependencies and a real project with
SDK imports, service aliases and exported project constants.
Every numeric case checks the selected intrinsic identity, exactly one retained
call, exact result bits or fault code, and per-instruction charging. Numeric costs
come from independent fixture rows; other instruction costs come from the provider
ISA contract. A full-budget execution must charge the sum of those steps.
Optimized and unoptimized versions must charge identical totals.
| Gate | Result |
| --- | --- |
| PBS frontend suite | 249 tests passed |
| Common backend suite | 175 passed, 12 pre-existing skips |
| Selected architecture/source suites | Math, existing values/input, structured values and closures passed |
| Installed knowledge | Both gates passed; packaged example imports math and aliased mathf |
| Complete production harness | Passed in dev and release, including 522 math vectors per profile |
| Workflow and patch integrity | discussion validate and git diff --check passed |
| Evidence artifact | SHA-256 |
| --- | --- |
| Runtime Cargo.lock | cffad9ed62f38a591538abd81dd39270d6022397342c8189f4ac6c7baaa8e795 |
| INTRINSICS.csv | 0c1bb78a9b81d1e3480ef5713f3d70f0b06772a7dfab2fd00c1f0a6364f98daa |
| BUILTIN_CONSTANTS.csv | e407e4718127aa7ef7b1097b5b4b67d86dd979235e73a551a7c36b628cddc039 |
| Provider numeric-conformance.tsv | 5536ee18cadaf32e3719b0e8d541dfcf1a84a49ea978a702101547c5ccdee3fe |
| Consumer numeric-source.tsv | 95067131dbc7a4252352424ee52f4b9215c8d8ecd80124218a38819211ff7ccb |
Reproduce from the Studio root:
```sh
./gradlew :prometeu-compiler:frontends:prometeu-frontend-pbs:test :prometeu-compiler:prometeu-build-pipeline:test
./gradlew :prometeu-architecture-tests:test --tests '*PbsRuntimeMathTest' --tests '*PbsRuntimeAlignmentTest' --tests '*PbsStructuredValuesTest' --tests '*PbsClosuresTest'
./gradlew :prometeu-app:installedKnowledgeTest
python3 tools/pbx-conformance/run.py --runtime ../runtime
python3 tools/pbx-conformance/run.py --runtime ../runtime --release
```
Optional CARGO_TARGET_DIR can preserve harness compilation artifacts in a temporary
directory. The script never writes to the runtime checkout. Use --math-only for
the complete math subset; it still rejects missing mandatory math fixtures.
Qualification on macOS/x86_64 and Linux/x86_64 remains pending. This delivery does
not qualify those hosts, installed-runtime deployment or a complete reference game.
The existing provider schema gaps for LifecycleRole and NonFiniteValue remain
explicitly reported by the full harness; original payloads are preserved.
## Pitfalls and maintenance
- Catalog parity is not source integration. Test the facade, imports, overloads,
actual emission and production VM together.
- Constants are not nullary intrinsics. Preserve their canonical bits and ordinary
load costs independently of method binding.
- A service alias changes source spelling, not the provider callable identity.
- Preserve constant ownership during expansion. Caller locals/globals must not
accidentally change the lexical meaning of a constant's initializer.
- Float equality hides the sign of zero. Conformance must compare raw bits.
- Intrinsic costs exclude wrapper and argument-producing instructions. Charge and
compare the complete program without treating virtual cycles as CPU timings.
- Extend the corpus and its mandatory count together. Never silently skip absent
fixtures, accept host tolerances, or replace provider oracles with compiler output.
## References
- [Service constants and runtime math specification](../../../docs/compiler/pbs/specs/service-constants-and-runtime-math.md)
- [Runtime catalog policy](../../../docs/compiler/general/specs/runtime-catalog-support.md)
- [Production harness](../../../tools/pbx-conformance/README.md)
- [Catalog-port lesson](../DSC-0075-compiler-runtime-catalog-parity/LSN-0080-manual-runtime-catalog-port-and-conformance.md)
- Historical execution artifacts: DEC-0069 and PLN-0148, removed by CLI housekeeping after completion.
Tooling note: the CLI has no lesson-allocation command. LSN-0085 was selected from
the next counter; CLI housekeeping registers the lesson and advances that counter.
@@ -0,0 +1,118 @@
# Service constants and runtime math
Owner: compiler/pbs. Common catalog authority: compiler/general. Numeric behavior,
exact identities, faults and virtual costs remain owned by the runtime.
## Services are the public namespaces
A service groups methods and immutable constants. The service barrel entry exports
both; constants are not independently exported as top-level symbols. This applies
to project code and SDK interfaces. Import aliases preserve the service identity.
```pbs
// @app:settings/main.pbs; mod.barrel contains: pub service Settings;
declare service Settings {
declare const base: int = 40;
declare const answer: int = base + 2;
fn read() -> int { return answer; }
}
```
Consumers can import `Settings` and read `Settings.answer`. Constants use the same
explicit type and constant-expression rules as top-level constants. Constant
initializers cannot invoke functions. Qualified dependencies are permitted;
unqualified names inside a constant initializer resolve in its owning service
before the top-level constant scope. Duplicate constants, a constant sharing a
method name, unresolved references, type mismatches and dependency cycles are
compile-time errors. Assignments to constants are invalid.
Reading `Service.constant` materializes its value without creating a singleton or
calling a getter. Ordinary methods retain existing service semantics. Constant
members are included in completion, hover, definition and document symbols.
## SDK math services
```pbs
import { math } from @sdk:math;
import { mathf as numbers } from @sdk:mathf;
fn example(counter: long, angle: float) -> float {
let bounded = math.clamp(counter, 0 as long, 100 as long);
return math.to_float(bounded) + numbers.sin(angle) + numbers.pi;
}
```
`math` supplies `min`, `max`, `clamp` and `abs`, each with exact `int` and `long`
overloads. `mathf` supplies `min`, `max`, `clamp`, `abs`, `floor`, `ceil`, `trunc`,
`round`, `sqrt`, `sin`, `cos` and `atan2`, all with `float` arguments and results.
`atan2` takes `(y, x)`; angles are radians. `float` is the runtime's finite binary64.
The six conversions are:
| Source call | Argument | Result |
| --- | --- | --- |
| `math.to_i64` | int | long |
| `math.to_i32` | long | int |
| `math.to_float` | int | float |
| `math.to_float` | long | float |
| `mathf.to_i32` | float | int |
| `mathf.to_i64` | float | long |
These are 26 exact intrinsic signatures in total. There are no identity
conversions. A mixed `int`/`long` call to `math.min` is invalid; the diagnostic
requires explicit conversion. Existing contextual integer literal rules do not
authorize implicit conversion of an already typed argument. Arithmetic opcode
promotion rules are unchanged.
## Binding and materialization
SDK service method signatures may carry `[IntrinsicCall(name = "...", version = 1)]`
and terminate with `;`. They have no PBS body or implicit numeric receiver in their
runtime signature. This reserved declaration form is restricted to SDK interfaces.
The generated callable loads its ordered arguments and invokes the exact common
catalog identity. No frontend numeric ID/cost map or host math implementation is
introduced. Normal compilation uses local versioned resources, not a runtime checkout.
SDK service constants may use `BuiltinConst` and omit their initializer:
```pbs
declare service mathf {
[BuiltinConst(target = "mathf", name = "pi", version = 1)]
declare const pi: float;
}
```
`mathf.pi` and `mathf.tau` MUST materialize `IRVMBuiltinConstantDefinition` values:
`0x400921FB54442D18` and `0x401921FB54442D18`. They are ordinary constant loads,
never synthetic intrinsic calls or host-calculated values. A constant expression
cannot replace a mathematical call: executable calls with literal arguments MUST
remain executable, including when their result is discarded or optimization runs.
## Numeric conformance
The runtime contract specifies signed zeros, subnormals, finite overflow, checked
conversions and ties-to-even rounding. For example, `sqrt(-0)` preserves -0,
`abs(-0)` produces +0, `round(2.5)` produces 2 and `round(3.5)` produces 4. Negative
nonzero sqrt and inverted clamp limits trap NUMERIC_DOMAIN. Integer abs(MIN) and
out-of-range conversions trap NUMERIC_RANGE. The frontend MUST preserve these
outcomes, argument order and virtual cycle accounting.
Integration evidence MUST begin with PBS source and end at the production VM.
The checked-in independent corpus combines provider MPFR-verified rows with exact
published contract examples. Tests require all 26 signatures, constants, mixed-type
rejections, explicit conversions, signed zeros, subnormals, extrema, range/domain
faults and atan2 axes. Both optimized and unoptimized emission are exercised.
The harness compares exact result bits and trap codes, and checks each executed
instruction's charge against the provider opcode contract and each numeric call
against its independent fixture cost. A full-budget run must charge their sum.
Constant-only probes additionally require exactly a load and root return cost.
Local qualification requires macOS/arm64 dev and release with runtime revision,
configuration and catalog/oracle hashes recorded. macOS/x86_64 and Linux/x86_64
remain separately pending; local results and cross-compilation do not qualify them.
## References
- [Common runtime catalog support](../../general/specs/runtime-catalog-support.md)
- [Runtime numeric contract](../../../../../runtime/docs/specs/runtime/02d-gameplay-math-and-numeric-semantics.md)
- [Production conformance harness](../../../../tools/pbx-conformance/README.md)
@@ -192,7 +192,7 @@ Rules:
- A `host` barrel entry must resolve to exactly one top-level `declare host` declaration in module scope.
- A `struct` barrel entry governs the visibility of the struct declaration and of all methods declared directly in that struct body.
- A `host` barrel entry governs the visibility of the host declaration and of all method signatures declared directly in that host body.
- A `service` barrel entry governs the visibility of the service declaration, its canonical singleton value, and all methods declared directly in that service body.
- A `service` barrel entry governs the visibility of the service declaration, its canonical singleton value, and all methods and constants declared directly in that service body.
- A `global` barrel entry governs visibility of one top-level `declare global` declaration.
- Methods declared inside a `struct`, `host`, or `service` are never exported independently through `mod.barrel`.
@@ -371,18 +371,19 @@ Function types use `Fn(T1, T2) -> R`. Lambdas use `fn [captures](name: Type) ->
```ebnf
ServiceDecl ::= 'declare' 'service' Identifier ServiceBody
ServiceBody ::= '{' ServiceMember* '}'
ServiceMember ::= 'fn' Identifier ParamList ReturnAnn? Block
ServiceMember ::= 'fn' Identifier ParamList ReturnAnn? Block | ConstDecl
// SDK only: an IntrinsicCall-attributed service signature may end in ';'.
```
Rules:
- `declare service Name { ... }` declares a nominal service type together with its canonical module-owned singleton value `Name`.
- A service body contains only method declarations.
- A service body contains method declarations and `declare const` members. SDK service intrinsic signatures may terminate with `;`; see [Service constants and runtime math](../../../compiler/pbs/specs/service-constants-and-runtime-math.md).
- Service methods have an implicit receiver binding `this` of type `Self` and do not declare `this: Self` explicitly.
- Services do not declare fields.
- Services do not declare `ctor`.
- Services are never constructed with `new`.
- Service method visibility follows the `service` entry for that declaration in `mod.barrel`; service methods are never exported independently.
- Service method visibility follows the `service` entry for that declaration in `mod.barrel`; service methods and constants are never exported independently.
### 7.4 Functions
@@ -96,7 +96,7 @@ Rules:
- The `Host` attribute syntax itself is not exported as runtime metadata; instead, its canonical identity participates in PBX host-binding emission as defined by the Host ABI Binding specification.
- `BuiltinType` is valid only on a reserved top-level `declare builtin type` declaration.
- `BuiltinConst` is valid only on a reserved top-level `declare const` declaration that omits an initializer.
- `IntrinsicCall` is valid only on a method signature declared directly inside a reserved `declare builtin type` body.
- `IntrinsicCall` is valid on a method signature inside a reserved `declare builtin type` body or an SDK service body. SDK service signatures have no implementation body and bind their exact declared argument/result carriers to the common intrinsic catalog.
- Builtin metadata is consumed by the compiler during VM-owned builtin and intrinsic lowering rather than by host-binding lowering.
- `Init` and `Frame` are consumed by lifecycle analysis and lowering rather than by ordinary runtime reflection.
- `InitAllowed` is consumed by init-time host-admission analysis and does not become ordinary userland metadata.
@@ -349,6 +349,11 @@ Rules:
### 3.6 Structs, services, methods, and contracts
Service constants follow [Service constants and runtime math](../../../compiler/pbs/specs/service-constants-and-runtime-math.md).
They are immutable members exported with their service. Qualified constant reads
materialize the constant without constructing a singleton or invoking a method.
Rules:
- Struct values are heap-backed reference values in v1 core.
@@ -16,17 +16,21 @@ class PbsRuntimeAlignmentTest {
assertNotNull(stream); return new String(stream.readAllBytes(), java.nio.charset.StandardCharsets.UTF_8);
}
}
private static BytecodeModule compile(String name,String source) throws Exception {
static BytecodeModule compile(String name,String source) throws Exception {
return compile(name, source, SourceKind.SDK_INTERFACE);
}
static BytecodeModule compile(String name,String source,SourceKind sourceKind) throws Exception {
var diagnostics=DiagnosticSink.empty();
var fileId = new FileId(0);
var ast = p.studio.compiler.pbs.parser.PbsParser.parse(p.studio.compiler.pbs.lexer.PbsLexer.lex(source,fileId,diagnostics),fileId,diagnostics,p.studio.compiler.pbs.parser.PbsParser.ParseMode.INTERFACE_MODULE);
var file=new PbsFrontendCompiler().compileParsedFile(fileId,ast,diagnostics,SourceKind.SDK_INTERFACE,
var file=new PbsFrontendCompiler().compileParsedFile(fileId,ast,diagnostics,sourceKind,
new p.studio.compiler.source.identifiers.ModuleId(0),p.studio.utilities.structures.ReadOnlyList.empty(),
p.studio.compiler.messages.HostAdmissionContext.permissiveDefault(),p.studio.compiler.messages.FESurfaceContext.empty(),new p.studio.compiler.source.tables.NameTable());
assertFalse(diagnostics.hasErrors(), ()->diagnostics.stream().map(d->d.getCode()+":"+d.getMessage()).toList().toString());
var backend=IRBackend.builder().entryPointCallableName("Probe.main").entryPointModuleId(new p.studio.compiler.source.identifiers.ModuleId(0)).executableFunctions(file.executableFunctions())
.globals(file.globals()).registry(file.registry()).intrinsicPool(file.intrinsicPool()).callableSignatures(file.callableSignatures()).build();
var program=new LowerToIRVMService().lower(backend);
if (name.endsWith("-optimized")) program = new OptimizeIRVMService().optimize(program);
var module=new BytecodeEmitter().emit(program.coherentEmissionPlan());
new BytecodePreloadVerifierService().verify(module);
var directory=Path.of(System.getProperty("pbs.registryConformanceDirectory"));Files.createDirectories(directory);
@@ -0,0 +1,129 @@
package p.studio.compiler.backend.irvm;
import org.junit.jupiter.api.Test;
import p.studio.compiler.pbs.PbsFrontendCompiler;
import p.studio.compiler.source.diagnostics.DiagnosticSink;
import p.studio.compiler.source.identifiers.FileId;
import p.studio.compiler.models.SourceKind;
import static org.junit.jupiter.api.Assertions.*;
class PbsRuntimeMathTest {
static String sdk() throws Exception {
var result = new StringBuilder();
for (var name : new String[]{"math", "mathf"}) {
try (var stream = PbsFrontendCompiler.class.getResourceAsStream("/game/stdlib/1/sdk/"+name+"/main.pbs")) {
assertNotNull(stream);
result.append(new String(stream.readAllBytes(), java.nio.charset.StandardCharsets.UTF_8));
}
}
return result.toString();
}
@Test void constantsAndOverloadsCompile() throws Exception {
PbsRuntimeAlignmentTest.compile("math-pi", sdk()+"declare service Probe { fn main() -> float { return mathf.pi; } }");
PbsRuntimeAlignmentTest.compile("math-tau", sdk()+"declare service Probe { fn main() -> float { return mathf.tau; } }");
PbsRuntimeAlignmentTest.compile("math-literal", sdk()+"declare service Probe { fn main() -> float { return mathf.sin(-0.0); } }");
PbsRuntimeAlignmentTest.compile("math-long", "declare service Settings { declare const limit: long = 2147483648; } declare service Probe { fn main() -> long { return Settings.limit; } }");
PbsRuntimeAlignmentTest.compile("math-min", sdk()+"declare service Probe { fn main() -> long { let a: long = 42; let b: long = 55; return math.min(a,b); } }");
PbsRuntimeAlignmentTest.compile("math-service", "declare service Settings { declare const answer: int = 42; } declare service Probe { fn main() -> int { return Settings.answer; } }");
}
@Test void invalidMembersAndMixedCarriersReject() throws Exception {
for (var body : new String[]{"return math.min(1, 2 as long);", "return mathf.sin(1);", "mathf.pi = 3.0; return 0;"}) {
var diagnostics = DiagnosticSink.empty();
new PbsFrontendCompiler().compileFile(new FileId(0),sdk()+"declare service Probe { fn main() -> int { "+body+" } }",diagnostics,SourceKind.SDK_INTERFACE);
assertTrue(diagnostics.hasErrors(), body);
}
}
@Test void providerCorpusCompilesEverySignatureFromSource() throws Exception {
var directory = java.nio.file.Path.of(System.getProperty("pbs.registryConformanceDirectory"));
String corpus;
try (var stream = getClass().getResourceAsStream("/math/numeric-source.tsv")) {
assertNotNull(stream);
corpus = new String(stream.readAllBytes(), java.nio.charset.StandardCharsets.UTF_8);
}
var manifest = new StringBuilder();
var covered = new java.util.HashSet<Integer>();
int index = 0;
for (var row : corpus.lines().toList()) {
var parts = row.split(" ");
int id = Integer.parseInt(parts[0], 16);
var definition = java.util.Arrays.stream(IRVMIntrinsicDefinition.values()).filter(d -> d.finalId() == id).findFirst().orElseThrow();
var source = new StringBuilder(sdk()).append("declare service Probe { fn main() -> ")
.append(sourceType(definition.retLayout())).append(" {");
var arguments = new java.util.ArrayList<String>();
var types = definition.argLayout().split("\\|");
for (int i = 0; i < types.length; i++) {
source.append("let a").append(i).append(": ").append(sourceType(types[i])).append(" = ")
.append(literal(parts[i+1])).append(";");
arguments.add("a"+i);
}
var name = definition.canonicalName().replace(".i32.", ".").replace(".i64.", ".");
source.append("return ").append(name).append("(").append(String.join(",",arguments)).append("); } }");
var fixture = "math-vector-" + index++;
PbsRuntimeAlignmentTest.compile(fixture, source.toString());
manifest.append("pbs-").append(fixture).append(" ").append(row).append("\n");
PbsRuntimeAlignmentTest.compile(fixture+"-optimized", source.toString());
manifest.append("pbs-").append(fixture).append("-optimized ").append(row).append("\n");
covered.add(id);
}
assertEquals(26, covered.size());
java.nio.file.Files.writeString(directory.resolve("math-vectors.tsv"), manifest);
}
private static String sourceType(String type) {
return switch(type) { case "Int32" -> "int"; case "Int64" -> "long"; case "Float" -> "float"; default -> throw new IllegalArgumentException(type); };
}
private static String literal(String token) {
if (!token.startsWith("f:")) return token.substring(2);
long bits = Long.parseUnsignedLong(token.substring(2),16);
if (bits == Long.MIN_VALUE) return "-0.0";
var result = java.math.BigDecimal.valueOf(Double.longBitsToDouble(bits)).toPlainString();
return result.contains(".") ? result : result + ".0";
}
@Test void qualifiedConstantDependenciesAndFailures() throws Exception {
PbsRuntimeAlignmentTest.compile("math-dependency", "declare global answer: int = 999; declare service Settings { declare const base: int = 40; declare const answer: int = base + 2; fn read() -> int { return answer; } } declare service Probe { fn main() -> int { answer = 999; return Settings.read(); } }", SourceKind.PROJECT);
for (var members : new String[]{
"declare const a: int = 1; declare const a: int = 2;",
"declare const a: int = Settings.b; declare const b: int = Settings.a;",
"declare const a: int = missing;",
"declare const a: int = 1; fn a() -> int { return 2; }",
"declare const a: int = true;"}) {
var diagnostics = DiagnosticSink.empty();
new PbsFrontendCompiler().compileFile(new FileId(0), "declare service Settings { "+members+" }", diagnostics);
assertTrue(diagnostics.hasErrors(), members);
}
for (var expression : new String[]{"math.min(1, 2 as long)", "mathf.sin(1)", "math.to_i64(1 as long)"}) {
var diagnostics = DiagnosticSink.empty();
new PbsFrontendCompiler().compileFile(new FileId(0),sdk()+"declare service Probe { fn main() { "+expression+"; } }",diagnostics,SourceKind.SDK_INTERFACE);
assertTrue(diagnostics.stream().anyMatch(d -> d.getMessage().contains("explicit conversion")), expression);
}
}
@Test void realModuleImportsAndAliasesProducePbx(@org.junit.jupiter.api.io.TempDir java.nio.file.Path root) throws Exception {
java.nio.file.Files.createDirectories(root.resolve("src/config"));
java.nio.file.Files.writeString(root.resolve("prometeu.json"), """
{"name":"app","version":"1.0.0","language":"pbs","stdlib":"1","target":"Game","dependencies":[]}
""");
java.nio.file.Files.writeString(root.resolve("src/config/main.pbs"), "declare service Settings { declare const answer: int = 42; }");
java.nio.file.Files.writeString(root.resolve("src/config/mod.barrel"), "pub service Settings;");
java.nio.file.Files.writeString(root.resolve("src/mod.barrel"), "pub fn frame() -> void;");
java.nio.file.Files.writeString(root.resolve("src/main.pbs"), """
import { math } from @sdk:math;
import { mathf as numbers } from @sdk:mathf;
import { Settings as config } from @app:config;
[Frame]
fn frame() -> void {
if config.answer != 42 { let fail = 1 / 0; }
if numbers.pi != 3.141592653589793 { let fail = 1 / 0; }
if numbers.sin(0.0) != 0.0 { let fail = 1 / 0; }
let value: long = 42;
if math.min(value, 55 as long) != value { let fail = 1 / 0; }
}
""");
var result = p.studio.compiler.workspaces.BuilderPipelineService.INSTANCE.compile(
p.studio.compiler.models.BuilderPipelineContext.fromConfig(new p.studio.compiler.messages.BuilderPipelineConfig(false, root.toString())),
p.studio.utilities.logs.LogAggregator.stdout());
assertFalse(result.diagnostics().stream().anyMatch(d -> d.isError()), result.diagnostics().toString());
assertTrue(result.bytecodeBytes().length > 0);
java.nio.file.Files.write(java.nio.file.Path.of(System.getProperty("pbs.registryConformanceDirectory"),"pbs-math-import.pbx"),result.bytecodeBytes());
}
}
@@ -0,0 +1,261 @@
3000 i:7 i:3 i:3 2
3001 i:7 i:3 i:7 2
3002 i:9 i:0 i:5 i:5 4
3003 i:-7 i:7 2
3004 l:2147483648 l:2147483649 l:2147483648 2
3005 l:2147483648 l:2147483649 l:2147483649 2
3006 l:9 l:0 l:5 l:5 4
3007 l:-7 l:7 2
3008 f:8000000000000000 f:0000000000000000 f:8000000000000000 2
3009 f:8000000000000000 f:0000000000000000 f:0000000000000000 2
300a f:8000000000000000 f:0000000000000000 f:3ff0000000000000 f:0000000000000000 4
300b f:8000000000000000 f:0000000000000000 2
3013 f:3ff0000000000000 f:0000000000000000 f:3ff921fb54442d18 48
3014 i:-2147483648 l:-2147483648 2
3015 l:2147483647 i:2147483647 2
3016 i:2147483647 f:41dfffffffc00000 2
3017 l:9223372036854775807 f:43e0000000000000 2
3003 i:-2147483648 trap:13 2
3007 l:-9223372036854775808 trap:13 2
3002 i:0 i:2 i:1 trap:12 4
300a f:0000000000000000 f:4000000000000000 f:3ff0000000000000 trap:12 4
3010 f:bff0000000000000 trap:12 16
3013 f:0000000000000000 f:0000000000000000 trap:12 48
3013 f:8000000000000000 f:bff0000000000000 f:c00921fb54442d18 48
3013 f:0000000000000000 f:bff0000000000000 f:400921fb54442d18 48
300f f:4004000000000000 f:4000000000000000 4
300f f:400c000000000000 f:4010000000000000 4
3015 l:2147483648 trap:13 2
3018 f:41e0000000000000 trap:13 2
3019 f:43e0000000000000 trap:13 2
3019 f:c3e0000000000000 l:-9223372036854775808 2
3017 l:9007199254740993 f:4340000000000000 2
3010 f:0000000000000000 f:0000000000000000 16
300c f:0000000000000000 f:0000000000000000 4
300d f:0000000000000000 f:0000000000000000 4
300e f:0000000000000000 f:0000000000000000 4
300f f:0000000000000000 f:0000000000000000 4
3018 f:0000000000000000 i:0 2
3019 f:0000000000000000 l:0 2
3011 f:0000000000000000 f:0000000000000000 32
3012 f:0000000000000000 f:3ff0000000000000 32
3011 f:8000000000000000 f:8000000000000000 32
3012 f:8000000000000000 f:3ff0000000000000 32
3013 f:0000000000000000 f:54edb5f397cc207d f:0000000000000000 48
3010 f:0000000000000001 f:1e60000000000000 16
300c f:0000000000000001 f:0000000000000000 4
300d f:0000000000000001 f:3ff0000000000000 4
300e f:0000000000000001 f:0000000000000000 4
300f f:0000000000000001 f:0000000000000000 4
3018 f:0000000000000001 i:0 2
3019 f:0000000000000001 l:0 2
3011 f:0000000000000001 f:0000000000000001 32
3012 f:0000000000000001 f:3ff0000000000000 32
3011 f:8000000000000001 f:8000000000000001 32
3012 f:8000000000000001 f:3ff0000000000000 32
3013 f:0000000000000001 f:823a3f3c9decf2dd f:400921fb54442d18 48
3010 f:0000000000000002 f:1e66a09e667f3bcd 16
300c f:0000000000000002 f:0000000000000000 4
300d f:0000000000000002 f:3ff0000000000000 4
300e f:0000000000000002 f:0000000000000000 4
300f f:0000000000000002 f:0000000000000000 4
3018 f:0000000000000002 i:0 2
3019 f:0000000000000002 l:0 2
3011 f:0000000000000002 f:0000000000000002 32
3012 f:0000000000000002 f:3ff0000000000000 32
3011 f:8000000000000002 f:8000000000000002 32
3012 f:8000000000000002 f:3ff0000000000000 32
3013 f:0000000000000002 f:8c9f4dfeacaf0126 f:400921fb54442d18 48
3010 f:000fffffffffffff f:1fffffffffffffff 16
300c f:000fffffffffffff f:0000000000000000 4
300d f:000fffffffffffff f:3ff0000000000000 4
300e f:000fffffffffffff f:0000000000000000 4
300f f:000fffffffffffff f:0000000000000000 4
3018 f:000fffffffffffff i:0 2
3019 f:000fffffffffffff l:0 2
3011 f:000fffffffffffff f:000fffffffffffff 32
3012 f:000fffffffffffff f:3ff0000000000000 32
3011 f:800fffffffffffff f:800fffffffffffff 32
3012 f:800fffffffffffff f:3ff0000000000000 32
3013 f:000fffffffffffff f:09ed7f8a283eb81c f:36115b63b5562616 48
3010 f:0010000000000000 f:2000000000000000 16
300c f:0010000000000000 f:0000000000000000 4
300d f:0010000000000000 f:3ff0000000000000 4
300e f:0010000000000000 f:0000000000000000 4
300f f:0010000000000000 f:0000000000000000 4
3018 f:0010000000000000 i:0 2
3019 f:0010000000000000 l:0 2
3011 f:0010000000000000 f:0010000000000000 32
3012 f:0010000000000000 f:3ff0000000000000 32
3011 f:8010000000000000 f:8010000000000000 32
3012 f:8010000000000000 f:3ff0000000000000 32
3013 f:0010000000000000 f:3feffffffffffffe f:0010000000000001 48
3010 f:3fdfffffffffffff f:3fe6a09e667f3bcc 16
300c f:3fdfffffffffffff f:0000000000000000 4
300d f:3fdfffffffffffff f:3ff0000000000000 4
300e f:3fdfffffffffffff f:0000000000000000 4
300f f:3fdfffffffffffff f:0000000000000000 4
3018 f:3fdfffffffffffff i:0 2
3019 f:3fdfffffffffffff l:0 2
3011 f:3fdfffffffffffff f:3fdeaee8744b05ef 32
3012 f:3fdfffffffffffff f:3fec1528065b7d50 32
3011 f:bfdfffffffffffff f:bfdeaee8744b05ef 32
3012 f:bfdfffffffffffff f:3fec1528065b7d50 32
3013 f:3fdfffffffffffff f:07faa1d222d1148d f:3ff921fb54442d18 48
3010 f:3fe0000000000000 f:3fe6a09e667f3bcd 16
300c f:3fe0000000000000 f:0000000000000000 4
300d f:3fe0000000000000 f:3ff0000000000000 4
300e f:3fe0000000000000 f:0000000000000000 4
300f f:3fe0000000000000 f:0000000000000000 4
3018 f:3fe0000000000000 i:0 2
3019 f:3fe0000000000000 l:0 2
3011 f:3fe0000000000000 f:3fdeaee8744b05f0 32
3012 f:3fe0000000000000 f:3fec1528065b7d50 32
3011 f:bfe0000000000000 f:bfdeaee8744b05f0 32
3012 f:bfe0000000000000 f:3fec1528065b7d50 32
3013 f:3fe0000000000000 f:ad7bbd56db31c9ec f:3ff921fb54442d18 48
3010 f:3fe0000000000001 f:3fe6a09e667f3bcd 16
300c f:3fe0000000000001 f:0000000000000000 4
300d f:3fe0000000000001 f:3ff0000000000000 4
300e f:3fe0000000000001 f:0000000000000000 4
300f f:3fe0000000000001 f:3ff0000000000000 4
3018 f:3fe0000000000001 i:0 2
3019 f:3fe0000000000001 l:0 2
3011 f:3fe0000000000001 f:3fdeaee8744b05f2 32
3012 f:3fe0000000000001 f:3fec1528065b7d4f 32
3011 f:bfe0000000000001 f:bfdeaee8744b05f2 32
3012 f:bfe0000000000001 f:3fec1528065b7d4f 32
3013 f:3fe0000000000001 f:3ffffffffffffffe f:3fcf5b75f92c80e1 48
3010 f:3ff0000000000000 f:3ff0000000000000 16
300c f:3ff0000000000000 f:3ff0000000000000 4
300d f:3ff0000000000000 f:3ff0000000000000 4
300e f:3ff0000000000000 f:3ff0000000000000 4
300f f:3ff0000000000000 f:3ff0000000000000 4
3018 f:3ff0000000000000 i:1 2
3019 f:3ff0000000000000 l:1 2
3011 f:3ff0000000000000 f:3feaed548f090cee 32
3012 f:3ff0000000000000 f:3fe14a280fb5068c 32
3011 f:bff0000000000000 f:bfeaed548f090cee 32
3012 f:bff0000000000000 f:3fe14a280fb5068c 32
3013 f:3ff0000000000000 f:3fe0000000000002 f:3ff1b6e192ebbe44 48
3010 f:4000000000000000 f:3ff6a09e667f3bcd 16
300c f:4000000000000000 f:4000000000000000 4
300d f:4000000000000000 f:4000000000000000 4
300e f:4000000000000000 f:4000000000000000 4
300f f:4000000000000000 f:4000000000000000 4
3018 f:4000000000000000 i:2 2
3019 f:4000000000000000 l:2 2
3011 f:4000000000000000 f:3fed18f6ead1b446 32
3012 f:4000000000000000 f:bfdaa22657537205 32
3011 f:c000000000000000 f:bfed18f6ead1b446 32
3012 f:c000000000000000 f:bfdaa22657537205 32
3013 f:4000000000000000 f:3ff921fb54442d18 f:3fecf5f1e82b5390 48
3010 f:3ff921fb54442d18 f:3ff40d931ff62705 16
300c f:3ff921fb54442d18 f:3ff0000000000000 4
300d f:3ff921fb54442d18 f:4000000000000000 4
300e f:3ff921fb54442d18 f:3ff0000000000000 4
300f f:3ff921fb54442d18 f:4000000000000000 4
3018 f:3ff921fb54442d18 i:1 2
3019 f:3ff921fb54442d18 l:1 2
3011 f:3ff921fb54442d18 f:3ff0000000000000 32
3012 f:3ff921fb54442d18 f:3c91a62633145c07 32
3011 f:bff921fb54442d18 f:bff0000000000000 32
3012 f:bff921fb54442d18 f:3c91a62633145c07 32
3013 f:3ff921fb54442d18 f:ea3931a1dc0ba585 f:400921fb54442d18 48
3010 f:400921fb54442d18 f:3ffc5bf891b4ef6a 16
300c f:400921fb54442d18 f:4008000000000000 4
300d f:400921fb54442d18 f:4010000000000000 4
300e f:400921fb54442d18 f:4008000000000000 4
300f f:400921fb54442d18 f:4008000000000000 4
3018 f:400921fb54442d18 i:3 2
3019 f:400921fb54442d18 l:3 2
3011 f:400921fb54442d18 f:3ca1a62633145c07 32
3012 f:400921fb54442d18 f:bff0000000000000 32
3011 f:c00921fb54442d18 f:bca1a62633145c07 32
3012 f:c00921fb54442d18 f:bff0000000000000 32
3013 f:400921fb54442d18 f:7103ecf9a81fd654 f:0ef42e61ed6e3c59 48
3010 f:401921fb54442d18 f:40040d931ff62705 16
300c f:401921fb54442d18 f:4018000000000000 4
300d f:401921fb54442d18 f:401c000000000000 4
300e f:401921fb54442d18 f:4018000000000000 4
300f f:401921fb54442d18 f:4018000000000000 4
3018 f:401921fb54442d18 i:6 2
3019 f:401921fb54442d18 l:6 2
3011 f:401921fb54442d18 f:bcb1a62633145c07 32
3012 f:401921fb54442d18 f:3ff0000000000000 32
3011 f:c01921fb54442d18 f:3cb1a62633145c07 32
3012 f:c01921fb54442d18 f:3ff0000000000000 32
3013 f:401921fb54442d18 f:22f1a991580a3c2b f:3ff921fb54442d18 48
3010 f:7fefffffffffffff f:5fefffffffffffff 16
300c f:7fefffffffffffff f:7fefffffffffffff 4
300d f:7fefffffffffffff f:7fefffffffffffff 4
300e f:7fefffffffffffff f:7fefffffffffffff 4
300f f:7fefffffffffffff f:7fefffffffffffff 4
3018 f:7fefffffffffffff trap:13 2
3019 f:7fefffffffffffff trap:13 2
3011 f:7fefffffffffffff f:3f7452fc98b34e97 32
3012 f:7fefffffffffffff f:bfefffe62ecfab75 32
3011 f:ffefffffffffffff f:bf7452fc98b34e97 32
3012 f:ffefffffffffffff f:bfefffe62ecfab75 32
3013 f:7fefffffffffffff f:3ff921fb54442d19 f:3ff921fb54442d18 48
3010 f:000ffffffffffffe f:1ffffffffffffffe 16
300c f:000ffffffffffffe f:0000000000000000 4
300d f:000ffffffffffffe f:3ff0000000000000 4
300e f:000ffffffffffffe f:0000000000000000 4
300f f:000ffffffffffffe f:0000000000000000 4
3018 f:000ffffffffffffe i:0 2
3019 f:000ffffffffffffe l:0 2
3011 f:000ffffffffffffe f:000ffffffffffffe 32
3012 f:000ffffffffffffe f:3ff0000000000000 32
3011 f:800ffffffffffffe f:800ffffffffffffe 32
3012 f:800ffffffffffffe f:3ff0000000000000 32
3013 f:000ffffffffffffe f:074caaf9d0e6af80 f:38b1dc162179e06b 48
3013 f:000fffffffffffff f:272b6a7c6b3a7cd8 f:18d2acdd5ccefbb4 48
3010 f:0010000000000001 f:2000000000000000 16
300c f:0010000000000001 f:0000000000000000 4
300d f:0010000000000001 f:3ff0000000000000 4
300e f:0010000000000001 f:0000000000000000 4
300f f:0010000000000001 f:0000000000000000 4
3018 f:0010000000000001 i:0 2
3019 f:0010000000000001 l:0 2
3011 f:0010000000000001 f:0010000000000001 32
3012 f:0010000000000001 f:3ff0000000000000 32
3011 f:8010000000000001 f:8010000000000001 32
3012 f:8010000000000001 f:3ff0000000000000 32
3013 f:0010000000000001 f:3feffffffffffffe f:0010000000000002 48
3010 f:0010000000000002 f:2000000000000001 16
300c f:0010000000000002 f:0000000000000000 4
300d f:0010000000000002 f:3ff0000000000000 4
300e f:0010000000000002 f:0000000000000000 4
300f f:0010000000000002 f:0000000000000000 4
3018 f:0010000000000002 i:0 2
3019 f:0010000000000002 l:0 2
3011 f:0010000000000002 f:0010000000000002 32
3012 f:0010000000000002 f:3ff0000000000000 32
3011 f:8010000000000002 f:8010000000000002 32
3012 f:8010000000000002 f:3ff0000000000000 32
3013 f:0010000000000002 f:7721df366e8fb3fd f:0000000000000000 48
3010 f:3fdffffffffffffd f:3fe6a09e667f3bcc 16
300c f:3fdffffffffffffd f:0000000000000000 4
300d f:3fdffffffffffffd f:3ff0000000000000 4
300e f:3fdffffffffffffd f:0000000000000000 4
300f f:3fdffffffffffffd f:0000000000000000 4
3018 f:3fdffffffffffffd i:0 2
3019 f:3fdffffffffffffd l:0 2
3011 f:3fdffffffffffffd f:3fdeaee8744b05ed 32
3012 f:3fdffffffffffffd f:3fec1528065b7d50 32
3011 f:bfdffffffffffffd f:bfdeaee8744b05ed 32
3012 f:bfdffffffffffffd f:3fec1528065b7d50 32
3013 f:3fdffffffffffffd f:7feffffffffffffe f:0002000000000000 48
3010 f:3fdffffffffffffe f:3fe6a09e667f3bcc 16
300c f:3fdffffffffffffe f:0000000000000000 4
300d f:3fdffffffffffffe f:3ff0000000000000 4
300e f:3fdffffffffffffe f:0000000000000000 4
300f f:3fdffffffffffffe f:0000000000000000 4
3018 f:3fdffffffffffffe i:0 2
3019 f:3fdffffffffffffe l:0 2
3011 f:3fdffffffffffffe f:3fdeaee8744b05ee 32
3012 f:3fdffffffffffffe f:3fec1528065b7d50 32
3011 f:bfdffffffffffffe f:bfdeaee8744b05ee 32
3012 f:bfdffffffffffffe f:3fec1528065b7d50 32
3013 f:3fdffffffffffffe f:401921fb54442d17 f:3fb45438e80932c3 48
1 3000 i:7 i:3 i:3 2
2 3001 i:7 i:3 i:7 2
3 3002 i:9 i:0 i:5 i:5 4
4 3003 i:-7 i:7 2
5 3004 l:2147483648 l:2147483649 l:2147483648 2
6 3005 l:2147483648 l:2147483649 l:2147483649 2
7 3006 l:9 l:0 l:5 l:5 4
8 3007 l:-7 l:7 2
9 3008 f:8000000000000000 f:0000000000000000 f:8000000000000000 2
10 3009 f:8000000000000000 f:0000000000000000 f:0000000000000000 2
11 300a f:8000000000000000 f:0000000000000000 f:3ff0000000000000 f:0000000000000000 4
12 300b f:8000000000000000 f:0000000000000000 2
13 3013 f:3ff0000000000000 f:0000000000000000 f:3ff921fb54442d18 48
14 3014 i:-2147483648 l:-2147483648 2
15 3015 l:2147483647 i:2147483647 2
16 3016 i:2147483647 f:41dfffffffc00000 2
17 3017 l:9223372036854775807 f:43e0000000000000 2
18 3003 i:-2147483648 trap:13 2
19 3007 l:-9223372036854775808 trap:13 2
20 3002 i:0 i:2 i:1 trap:12 4
21 300a f:0000000000000000 f:4000000000000000 f:3ff0000000000000 trap:12 4
22 3010 f:bff0000000000000 trap:12 16
23 3013 f:0000000000000000 f:0000000000000000 trap:12 48
24 3013 f:8000000000000000 f:bff0000000000000 f:c00921fb54442d18 48
25 3013 f:0000000000000000 f:bff0000000000000 f:400921fb54442d18 48
26 300f f:4004000000000000 f:4000000000000000 4
27 300f f:400c000000000000 f:4010000000000000 4
28 3015 l:2147483648 trap:13 2
29 3018 f:41e0000000000000 trap:13 2
30 3019 f:43e0000000000000 trap:13 2
31 3019 f:c3e0000000000000 l:-9223372036854775808 2
32 3017 l:9007199254740993 f:4340000000000000 2
33 3010 f:0000000000000000 f:0000000000000000 16
34 300c f:0000000000000000 f:0000000000000000 4
35 300d f:0000000000000000 f:0000000000000000 4
36 300e f:0000000000000000 f:0000000000000000 4
37 300f f:0000000000000000 f:0000000000000000 4
38 3018 f:0000000000000000 i:0 2
39 3019 f:0000000000000000 l:0 2
40 3011 f:0000000000000000 f:0000000000000000 32
41 3012 f:0000000000000000 f:3ff0000000000000 32
42 3011 f:8000000000000000 f:8000000000000000 32
43 3012 f:8000000000000000 f:3ff0000000000000 32
44 3013 f:0000000000000000 f:54edb5f397cc207d f:0000000000000000 48
45 3010 f:0000000000000001 f:1e60000000000000 16
46 300c f:0000000000000001 f:0000000000000000 4
47 300d f:0000000000000001 f:3ff0000000000000 4
48 300e f:0000000000000001 f:0000000000000000 4
49 300f f:0000000000000001 f:0000000000000000 4
50 3018 f:0000000000000001 i:0 2
51 3019 f:0000000000000001 l:0 2
52 3011 f:0000000000000001 f:0000000000000001 32
53 3012 f:0000000000000001 f:3ff0000000000000 32
54 3011 f:8000000000000001 f:8000000000000001 32
55 3012 f:8000000000000001 f:3ff0000000000000 32
56 3013 f:0000000000000001 f:823a3f3c9decf2dd f:400921fb54442d18 48
57 3010 f:0000000000000002 f:1e66a09e667f3bcd 16
58 300c f:0000000000000002 f:0000000000000000 4
59 300d f:0000000000000002 f:3ff0000000000000 4
60 300e f:0000000000000002 f:0000000000000000 4
61 300f f:0000000000000002 f:0000000000000000 4
62 3018 f:0000000000000002 i:0 2
63 3019 f:0000000000000002 l:0 2
64 3011 f:0000000000000002 f:0000000000000002 32
65 3012 f:0000000000000002 f:3ff0000000000000 32
66 3011 f:8000000000000002 f:8000000000000002 32
67 3012 f:8000000000000002 f:3ff0000000000000 32
68 3013 f:0000000000000002 f:8c9f4dfeacaf0126 f:400921fb54442d18 48
69 3010 f:000fffffffffffff f:1fffffffffffffff 16
70 300c f:000fffffffffffff f:0000000000000000 4
71 300d f:000fffffffffffff f:3ff0000000000000 4
72 300e f:000fffffffffffff f:0000000000000000 4
73 300f f:000fffffffffffff f:0000000000000000 4
74 3018 f:000fffffffffffff i:0 2
75 3019 f:000fffffffffffff l:0 2
76 3011 f:000fffffffffffff f:000fffffffffffff 32
77 3012 f:000fffffffffffff f:3ff0000000000000 32
78 3011 f:800fffffffffffff f:800fffffffffffff 32
79 3012 f:800fffffffffffff f:3ff0000000000000 32
80 3013 f:000fffffffffffff f:09ed7f8a283eb81c f:36115b63b5562616 48
81 3010 f:0010000000000000 f:2000000000000000 16
82 300c f:0010000000000000 f:0000000000000000 4
83 300d f:0010000000000000 f:3ff0000000000000 4
84 300e f:0010000000000000 f:0000000000000000 4
85 300f f:0010000000000000 f:0000000000000000 4
86 3018 f:0010000000000000 i:0 2
87 3019 f:0010000000000000 l:0 2
88 3011 f:0010000000000000 f:0010000000000000 32
89 3012 f:0010000000000000 f:3ff0000000000000 32
90 3011 f:8010000000000000 f:8010000000000000 32
91 3012 f:8010000000000000 f:3ff0000000000000 32
92 3013 f:0010000000000000 f:3feffffffffffffe f:0010000000000001 48
93 3010 f:3fdfffffffffffff f:3fe6a09e667f3bcc 16
94 300c f:3fdfffffffffffff f:0000000000000000 4
95 300d f:3fdfffffffffffff f:3ff0000000000000 4
96 300e f:3fdfffffffffffff f:0000000000000000 4
97 300f f:3fdfffffffffffff f:0000000000000000 4
98 3018 f:3fdfffffffffffff i:0 2
99 3019 f:3fdfffffffffffff l:0 2
100 3011 f:3fdfffffffffffff f:3fdeaee8744b05ef 32
101 3012 f:3fdfffffffffffff f:3fec1528065b7d50 32
102 3011 f:bfdfffffffffffff f:bfdeaee8744b05ef 32
103 3012 f:bfdfffffffffffff f:3fec1528065b7d50 32
104 3013 f:3fdfffffffffffff f:07faa1d222d1148d f:3ff921fb54442d18 48
105 3010 f:3fe0000000000000 f:3fe6a09e667f3bcd 16
106 300c f:3fe0000000000000 f:0000000000000000 4
107 300d f:3fe0000000000000 f:3ff0000000000000 4
108 300e f:3fe0000000000000 f:0000000000000000 4
109 300f f:3fe0000000000000 f:0000000000000000 4
110 3018 f:3fe0000000000000 i:0 2
111 3019 f:3fe0000000000000 l:0 2
112 3011 f:3fe0000000000000 f:3fdeaee8744b05f0 32
113 3012 f:3fe0000000000000 f:3fec1528065b7d50 32
114 3011 f:bfe0000000000000 f:bfdeaee8744b05f0 32
115 3012 f:bfe0000000000000 f:3fec1528065b7d50 32
116 3013 f:3fe0000000000000 f:ad7bbd56db31c9ec f:3ff921fb54442d18 48
117 3010 f:3fe0000000000001 f:3fe6a09e667f3bcd 16
118 300c f:3fe0000000000001 f:0000000000000000 4
119 300d f:3fe0000000000001 f:3ff0000000000000 4
120 300e f:3fe0000000000001 f:0000000000000000 4
121 300f f:3fe0000000000001 f:3ff0000000000000 4
122 3018 f:3fe0000000000001 i:0 2
123 3019 f:3fe0000000000001 l:0 2
124 3011 f:3fe0000000000001 f:3fdeaee8744b05f2 32
125 3012 f:3fe0000000000001 f:3fec1528065b7d4f 32
126 3011 f:bfe0000000000001 f:bfdeaee8744b05f2 32
127 3012 f:bfe0000000000001 f:3fec1528065b7d4f 32
128 3013 f:3fe0000000000001 f:3ffffffffffffffe f:3fcf5b75f92c80e1 48
129 3010 f:3ff0000000000000 f:3ff0000000000000 16
130 300c f:3ff0000000000000 f:3ff0000000000000 4
131 300d f:3ff0000000000000 f:3ff0000000000000 4
132 300e f:3ff0000000000000 f:3ff0000000000000 4
133 300f f:3ff0000000000000 f:3ff0000000000000 4
134 3018 f:3ff0000000000000 i:1 2
135 3019 f:3ff0000000000000 l:1 2
136 3011 f:3ff0000000000000 f:3feaed548f090cee 32
137 3012 f:3ff0000000000000 f:3fe14a280fb5068c 32
138 3011 f:bff0000000000000 f:bfeaed548f090cee 32
139 3012 f:bff0000000000000 f:3fe14a280fb5068c 32
140 3013 f:3ff0000000000000 f:3fe0000000000002 f:3ff1b6e192ebbe44 48
141 3010 f:4000000000000000 f:3ff6a09e667f3bcd 16
142 300c f:4000000000000000 f:4000000000000000 4
143 300d f:4000000000000000 f:4000000000000000 4
144 300e f:4000000000000000 f:4000000000000000 4
145 300f f:4000000000000000 f:4000000000000000 4
146 3018 f:4000000000000000 i:2 2
147 3019 f:4000000000000000 l:2 2
148 3011 f:4000000000000000 f:3fed18f6ead1b446 32
149 3012 f:4000000000000000 f:bfdaa22657537205 32
150 3011 f:c000000000000000 f:bfed18f6ead1b446 32
151 3012 f:c000000000000000 f:bfdaa22657537205 32
152 3013 f:4000000000000000 f:3ff921fb54442d18 f:3fecf5f1e82b5390 48
153 3010 f:3ff921fb54442d18 f:3ff40d931ff62705 16
154 300c f:3ff921fb54442d18 f:3ff0000000000000 4
155 300d f:3ff921fb54442d18 f:4000000000000000 4
156 300e f:3ff921fb54442d18 f:3ff0000000000000 4
157 300f f:3ff921fb54442d18 f:4000000000000000 4
158 3018 f:3ff921fb54442d18 i:1 2
159 3019 f:3ff921fb54442d18 l:1 2
160 3011 f:3ff921fb54442d18 f:3ff0000000000000 32
161 3012 f:3ff921fb54442d18 f:3c91a62633145c07 32
162 3011 f:bff921fb54442d18 f:bff0000000000000 32
163 3012 f:bff921fb54442d18 f:3c91a62633145c07 32
164 3013 f:3ff921fb54442d18 f:ea3931a1dc0ba585 f:400921fb54442d18 48
165 3010 f:400921fb54442d18 f:3ffc5bf891b4ef6a 16
166 300c f:400921fb54442d18 f:4008000000000000 4
167 300d f:400921fb54442d18 f:4010000000000000 4
168 300e f:400921fb54442d18 f:4008000000000000 4
169 300f f:400921fb54442d18 f:4008000000000000 4
170 3018 f:400921fb54442d18 i:3 2
171 3019 f:400921fb54442d18 l:3 2
172 3011 f:400921fb54442d18 f:3ca1a62633145c07 32
173 3012 f:400921fb54442d18 f:bff0000000000000 32
174 3011 f:c00921fb54442d18 f:bca1a62633145c07 32
175 3012 f:c00921fb54442d18 f:bff0000000000000 32
176 3013 f:400921fb54442d18 f:7103ecf9a81fd654 f:0ef42e61ed6e3c59 48
177 3010 f:401921fb54442d18 f:40040d931ff62705 16
178 300c f:401921fb54442d18 f:4018000000000000 4
179 300d f:401921fb54442d18 f:401c000000000000 4
180 300e f:401921fb54442d18 f:4018000000000000 4
181 300f f:401921fb54442d18 f:4018000000000000 4
182 3018 f:401921fb54442d18 i:6 2
183 3019 f:401921fb54442d18 l:6 2
184 3011 f:401921fb54442d18 f:bcb1a62633145c07 32
185 3012 f:401921fb54442d18 f:3ff0000000000000 32
186 3011 f:c01921fb54442d18 f:3cb1a62633145c07 32
187 3012 f:c01921fb54442d18 f:3ff0000000000000 32
188 3013 f:401921fb54442d18 f:22f1a991580a3c2b f:3ff921fb54442d18 48
189 3010 f:7fefffffffffffff f:5fefffffffffffff 16
190 300c f:7fefffffffffffff f:7fefffffffffffff 4
191 300d f:7fefffffffffffff f:7fefffffffffffff 4
192 300e f:7fefffffffffffff f:7fefffffffffffff 4
193 300f f:7fefffffffffffff f:7fefffffffffffff 4
194 3018 f:7fefffffffffffff trap:13 2
195 3019 f:7fefffffffffffff trap:13 2
196 3011 f:7fefffffffffffff f:3f7452fc98b34e97 32
197 3012 f:7fefffffffffffff f:bfefffe62ecfab75 32
198 3011 f:ffefffffffffffff f:bf7452fc98b34e97 32
199 3012 f:ffefffffffffffff f:bfefffe62ecfab75 32
200 3013 f:7fefffffffffffff f:3ff921fb54442d19 f:3ff921fb54442d18 48
201 3010 f:000ffffffffffffe f:1ffffffffffffffe 16
202 300c f:000ffffffffffffe f:0000000000000000 4
203 300d f:000ffffffffffffe f:3ff0000000000000 4
204 300e f:000ffffffffffffe f:0000000000000000 4
205 300f f:000ffffffffffffe f:0000000000000000 4
206 3018 f:000ffffffffffffe i:0 2
207 3019 f:000ffffffffffffe l:0 2
208 3011 f:000ffffffffffffe f:000ffffffffffffe 32
209 3012 f:000ffffffffffffe f:3ff0000000000000 32
210 3011 f:800ffffffffffffe f:800ffffffffffffe 32
211 3012 f:800ffffffffffffe f:3ff0000000000000 32
212 3013 f:000ffffffffffffe f:074caaf9d0e6af80 f:38b1dc162179e06b 48
213 3013 f:000fffffffffffff f:272b6a7c6b3a7cd8 f:18d2acdd5ccefbb4 48
214 3010 f:0010000000000001 f:2000000000000000 16
215 300c f:0010000000000001 f:0000000000000000 4
216 300d f:0010000000000001 f:3ff0000000000000 4
217 300e f:0010000000000001 f:0000000000000000 4
218 300f f:0010000000000001 f:0000000000000000 4
219 3018 f:0010000000000001 i:0 2
220 3019 f:0010000000000001 l:0 2
221 3011 f:0010000000000001 f:0010000000000001 32
222 3012 f:0010000000000001 f:3ff0000000000000 32
223 3011 f:8010000000000001 f:8010000000000001 32
224 3012 f:8010000000000001 f:3ff0000000000000 32
225 3013 f:0010000000000001 f:3feffffffffffffe f:0010000000000002 48
226 3010 f:0010000000000002 f:2000000000000001 16
227 300c f:0010000000000002 f:0000000000000000 4
228 300d f:0010000000000002 f:3ff0000000000000 4
229 300e f:0010000000000002 f:0000000000000000 4
230 300f f:0010000000000002 f:0000000000000000 4
231 3018 f:0010000000000002 i:0 2
232 3019 f:0010000000000002 l:0 2
233 3011 f:0010000000000002 f:0010000000000002 32
234 3012 f:0010000000000002 f:3ff0000000000000 32
235 3011 f:8010000000000002 f:8010000000000002 32
236 3012 f:8010000000000002 f:3ff0000000000000 32
237 3013 f:0010000000000002 f:7721df366e8fb3fd f:0000000000000000 48
238 3010 f:3fdffffffffffffd f:3fe6a09e667f3bcc 16
239 300c f:3fdffffffffffffd f:0000000000000000 4
240 300d f:3fdffffffffffffd f:3ff0000000000000 4
241 300e f:3fdffffffffffffd f:0000000000000000 4
242 300f f:3fdffffffffffffd f:0000000000000000 4
243 3018 f:3fdffffffffffffd i:0 2
244 3019 f:3fdffffffffffffd l:0 2
245 3011 f:3fdffffffffffffd f:3fdeaee8744b05ed 32
246 3012 f:3fdffffffffffffd f:3fec1528065b7d50 32
247 3011 f:bfdffffffffffffd f:bfdeaee8744b05ed 32
248 3012 f:bfdffffffffffffd f:3fec1528065b7d50 32
249 3013 f:3fdffffffffffffd f:7feffffffffffffe f:0002000000000000 48
250 3010 f:3fdffffffffffffe f:3fe6a09e667f3bcc 16
251 300c f:3fdffffffffffffe f:0000000000000000 4
252 300d f:3fdffffffffffffe f:3ff0000000000000 4
253 300e f:3fdffffffffffffe f:0000000000000000 4
254 300f f:3fdffffffffffffe f:0000000000000000 4
255 3018 f:3fdffffffffffffe i:0 2
256 3019 f:3fdffffffffffffe l:0 2
257 3011 f:3fdffffffffffffe f:3fdeaee8744b05ee 32
258 3012 f:3fdffffffffffffe f:3fec1528065b7d50 32
259 3011 f:bfdffffffffffffe f:bfdeaee8744b05ee 32
260 3012 f:bfdffffffffffffe f:3fec1528065b7d50 32
261 3013 f:3fdffffffffffffe f:401921fb54442d17 f:3fb45438e80932c3 48
@@ -0,0 +1,3 @@
Runtime revision: f7d7c167531bb662a1af9d73fc326bb476bf8aa7
Provider fixture SHA-256: 5536ee18cadaf32e3719b0e8d541dfcf1a84a49ea978a702101547c5ccdee3fe
First 240 scalar rows of numeric-conformance.tsv plus exact examples from 02d-gameplay-math-and-numeric-semantics.md. No host math oracle.
@@ -41,6 +41,11 @@ public final class PbsReservedMetadataExtractor {
extractBuiltinTypeSurface(builtinTypeDecl, inferredLayoutsByName, builtinTypeSurfaces);
continue;
}
if (topDecl instanceof PbsAst.ServiceDecl service) {
for (var constant : service.constants()) extractBuiltinConstSurface(
new PbsAst.ConstDecl(service.name() + "." + constant.name(), constant.explicitType(),
constant.initializer(), constant.attributes(), constant.span()), builtinConstSurfaces);
}
if (topDecl instanceof PbsAst.ConstDecl constDecl) {
extractBuiltinConstSurface(constDecl, builtinConstSurfaces);
}
@@ -0,0 +1,30 @@
package p.studio.compiler.pbs;
import p.studio.compiler.pbs.ast.PbsAst;
import p.studio.utilities.structures.ReadOnlyList;
import java.util.LinkedHashMap;
import java.util.Map;
/** Constant identities retain their service owner, including across imports. */
public final class PbsServiceConstants {
private PbsServiceConstants() {}
public static Map<String, PbsAst.ConstDecl> collect(ReadOnlyList<PbsAst.TopDecl> declarations) {
var result = new LinkedHashMap<String, PbsAst.ConstDecl>();
for (var declaration : declarations) {
if (declaration instanceof PbsAst.ConstDecl constant) result.putIfAbsent(constant.name(), constant);
if (declaration instanceof PbsAst.ServiceDecl service)
for (var constant : service.constants()) result.putIfAbsent(service.name() + "." + constant.name(), constant);
}
return result;
}
public static String path(PbsAst.Expression expression) {
if (expression instanceof PbsAst.IdentifierExpr name) return name.name();
if (expression instanceof PbsAst.MemberExpr member) {
var owner = path(member.receiver());
return owner == null ? null : owner + "." + member.memberName();
}
return null;
}
}
@@ -180,8 +180,13 @@ public final class PbsAst {
public record ServiceDecl(
String name,
ReadOnlyList<FunctionDecl> methods,
ReadOnlyList<ConstDecl> constants,
ReadOnlyList<Attribute> attributes,
Span span) implements TopDecl {
public ServiceDecl(String name, ReadOnlyList<FunctionDecl> methods,
ReadOnlyList<Attribute> attributes, Span span) {
this(name, methods, ReadOnlyList.empty(), attributes, span);
}
}
public record ErrorDecl(
@@ -58,7 +58,29 @@ final class PbsExecutableBodyLowerer {
int slot = context.declareLocalSlots(capture.label(), context.types().slots(type));
emitStoreLocalSlots(slot, context.types().slots(type), capture.span(), context);
}
final var terminated = lowerBlock(functionDecl.body(), context);
var binding = functionDecl.attributes().stream().filter(a -> "IntrinsicCall".equals(a.name())).findFirst();
final boolean terminated;
if (binding.isPresent()) {
var attribute = binding.get();
var name = attribute.arguments().stream().filter(a -> "name".equals(a.name()))
.map(a -> ((PbsAst.AttributeStringValue) a.value()).value()).findFirst().orElseThrow();
if (name.startsWith("\"")) name = name.substring(1, name.length()-1);
long version = attribute.arguments().stream().filter(a -> "version".equals(a.name()))
.mapToLong(a -> ((PbsAst.AttributeIntValue) a.value()).value()).findFirst().orElseThrow();
int slots = 0;
for (var parameter : functionDecl.parameters()) {
int width = context.types().slots(parameter.typeRef());
emitLoadLocalSlots(slots, width, parameter.span(), context);
slots += width;
}
context.instructions().add(new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.CALL_INTRINSIC, "", null,
new IRBackendExecutableFunction.IntrinsicCallMetadata(name, version, intrinsicIdTable.register(name, version)),
slots, context.types().slots(functionDecl.returnType()), functionDecl.span()));
context.instructions().add(new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.RET, "", null, null, null, functionDecl.span()));
terminated = true;
} else terminated = lowerBlock(functionDecl.body(), context);
finalizeFunctionInstructions(functionDecl, context, terminated);
final var returnSlots = functionDecl.returnKind() == PbsAst.ReturnKind.PLAIN ? context.types().slots(functionDecl.returnType()) : 0;
@@ -612,6 +634,21 @@ final class PbsExecutableBodyLowerer {
final PbsAst.MemberExpr memberExpr,
final PbsExecutableLoweringContext context) {
var receiverType = PbsRuntimeTypes.unwrap(expressionType(memberExpr.receiver(), context));
var service = receiverType == null ? null : context.types().services.get(receiverType.name());
if (service != null) {
var key = service.name() + "." + memberExpr.memberName();
if (context.types().constants.containsKey(key)) {
boolean staticOwner = memberExpr.receiver() instanceof PbsAst.IdentifierExpr name
&& !context.localTypes.containsKey(name.name()) && context.types().services.containsKey(name.name());
if (!staticOwner && !(memberExpr.receiver() instanceof PbsAst.ThisExpr)) {
lowerExpected(memberExpr.receiver(), receiverType, context);
context.instructions().add(new IRBackendExecutableFunction.Instruction(
IRBackendExecutableFunction.InstructionKind.POP, "", null, null, memberExpr.span()));
}
lowerConstant(key, memberExpr.span(), context);
return;
}
}
if (receiverType != null && receiverType.kind() == PbsAst.TypeRefKind.ARRAY && memberExpr.memberName().equals("length")) {
lowerExpected(memberExpr.receiver(), receiverType, context);
registry(ARRAY_LEN, context.types().arrayStorage(), 0, 1, 1, memberExpr.span(), context);
@@ -753,6 +790,11 @@ final class PbsExecutableBodyLowerer {
}
return;
}
var memberKey = context.serviceOwner + "." + identifierExpr.name();
if (context.types().constants.containsKey(memberKey)) {
lowerConstant(memberKey, identifierExpr.span(), context);
return;
}
final var globalSlot = context.resolveGlobalSlot(identifierExpr.name());
if (globalSlot != null) {
emitGetGlobal(globalSlot, identifierExpr.span(), context);
@@ -774,6 +816,25 @@ final class PbsExecutableBodyLowerer {
}
}
private void lowerConstant(String key, Span span, PbsExecutableLoweringContext context) {
var constant = context.types().constants.get(key);
var previousOwner = context.serviceOwner;
var previousExpected = context.expectedType;
try {
context.serviceOwner = key.contains(".") ? key.substring(0, key.lastIndexOf('.')) : "";
context.expectedType = constant.explicitType();
if (constant.initializer() != null) lowerConstExpression(constant.initializer(), context);
else {
var builtin = context.builtinConstByNameId().get(context.nameTable().register(key));
if (builtin == null) reportUnsupportedLowering("Missing builtin constant: " + key, span, context);
else emitBuiltinConstFetch(builtin, span, context);
}
} finally {
context.serviceOwner = previousOwner;
context.expectedType = previousExpected;
}
}
private void emitBuiltinConstFetch(
final p.studio.compiler.models.IRReservedMetadata.BuiltinConstSurface builtinConst,
final p.studio.compiler.source.Span span,
@@ -904,7 +965,8 @@ final class PbsExecutableBodyLowerer {
}
return context.resolveLocalSlot(identifierExpr.name()) != null
|| context.resolveGlobalSlot(identifierExpr.name()) != null
|| context.resolveConstDecl(identifierExpr.name()) != null;
|| context.resolveConstDecl(identifierExpr.name()) != null
|| context.types().constants.containsKey(context.serviceOwner + "." + identifierExpr.name());
}
private int identifierValueSlots(
@@ -944,6 +1006,8 @@ final class PbsExecutableBodyLowerer {
lowerIntLiteral(new PbsAst.IntLiteralExpr(boundedLiteralExpr.value(), boundedLiteralExpr.span()), context);
case PbsAst.StringLiteralExpr stringLiteralExpr -> emitPushConst(stringLiteralExpr.value(), stringLiteralExpr.span(), context);
case PbsAst.BoolLiteralExpr boolLiteralExpr -> emitPushBool(boolLiteralExpr.value(), boolLiteralExpr.span(), context);
case PbsAst.FloatLiteralExpr literal -> lowerExpression(literal, context);
case PbsAst.MemberExpr member -> lowerMemberExpression(member, context);
case PbsAst.GroupExpr groupExpr -> lowerConstExpression(groupExpr.expression(), context);
case PbsAst.UnaryExpr unaryExpr -> {
lowerConstExpression(unaryExpr.expression(), context);
@@ -955,9 +1019,10 @@ final class PbsExecutableBodyLowerer {
emitBinaryOperatorInstruction(binaryExpr.operator(), binaryExpr.span(), context);
}
case PbsAst.IdentifierExpr identifierExpr -> {
final var referenced = context.resolveConstDecl(identifierExpr.name());
if (referenced != null && referenced.initializer() != null) {
lowerConstExpression(referenced.initializer(), context);
var key = context.serviceOwner + "." + identifierExpr.name();
if (!context.types().constants.containsKey(key)) key = identifierExpr.name();
if (context.types().constants.containsKey(key)) {
lowerConstant(key, identifierExpr.span(), context);
} else {
reportUnsupportedLowering("const identifier is not lowerable: " + identifierExpr.name(), identifierExpr.span(), context);
}
@@ -1046,6 +1111,12 @@ final class PbsExecutableBodyLowerer {
if (e instanceof PbsAst.ElseExpr fallback) {var opt = PbsRuntimeTypes.unwrap(expressionType(fallback.optionalExpression(), c)); return opt == null ? null : opt.inner();}
if (e instanceof PbsAst.IndexExpr index) {var array = PbsRuntimeTypes.unwrap(expressionType(index.receiver(), c)); return array == null ? null : PbsAst.TypeRef.optional(array.inner(), index.span());}
if (e instanceof PbsAst.MemberExpr member) {
var serviceType = expressionType(member.receiver(), c);
var service = serviceType == null ? null : c.types().services.get(serviceType.name());
if (service != null) {
var constant = c.types().constants.get(service.name() + "." + member.memberName());
if (constant != null) return constant.explicitType();
}
var receiver = PbsRuntimeTypes.unwrap(expressionType(member.receiver(), c));
if (receiver != null && receiver.kind() == PbsAst.TypeRefKind.ARRAY && member.memberName().equals("length")) return PbsRuntimeTypes.type("long");
if (receiver != null && receiver.kind() == PbsAst.TypeRefKind.NAMED_TUPLE)
@@ -1055,7 +1126,7 @@ final class PbsExecutableBodyLowerer {
}
if (e instanceof PbsAst.IdentifierExpr i) {
if(c.types().services.containsKey(i.name()))return PbsRuntimeTypes.type(i.name());
var local = c.localTypes.getOrDefault(i.name(), c.types().values.get(i.name()));
var local = c.localTypes.getOrDefault(i.name(), c.types().values.getOrDefault(c.serviceOwner + "." + i.name(), c.types().values.get(i.name())));
if (local != null) return local;
var functions = c.types().functions.get(i.name());
if (functions != null && !functions.isEmpty()) {
@@ -1107,6 +1178,10 @@ final class PbsExecutableBodyLowerer {
return sig == null ? null : sig.returnType();
}
if (e instanceof PbsAst.MemberExpr m && m.receiver() instanceof PbsAst.IdentifierExpr i) {
if (!c.localTypes.containsKey(i.name())) {
var key = c.types().aliases.getOrDefault(i.name(), i.name()) + "." + m.memberName();
if (c.types().constants.containsKey(key)) return c.types().constants.get(key).explicitType();
}
if (c.types().enums.containsKey(i.name())) return PbsRuntimeTypes.type(i.name());
var owner = c.localTypes.get(i.name());
var fields = owner == null ? null : c.types().fields.get(owner.name());
@@ -1694,7 +1769,7 @@ final class PbsExecutableBodyLowerer {
}
int pops=0;
for(int i=0;i<call.arguments().size();i++){var type=PbsTypeSubstitution.replaceSelf(method.parameters().get(i).typeRef(),owner.name());lowerExpected(call.arguments().get(i),type,c);pops+=c.types().slots(type);}
emitStructuredFunction(owner.name()+"."+method.name(),method.parameters().stream().map(PbsAst.Parameter::typeRef).toList(),PbsTypeSubstitution.replaceSelf(method.returnType(),owner.name()),pops,c.types().slots(method.returnType()),call.span(),c);return true;
emitStructuredFunction(service.name()+"."+method.name(),method.parameters().stream().map(PbsAst.Parameter::typeRef).toList(),PbsTypeSubstitution.replaceSelf(method.returnType(),owner.name()),pops,c.types().slots(method.returnType()),call.span(),c);return true;
}
var struct=c.types().structs.get(owner.name());if(struct==null)return false;
var method=struct.methods().stream().filter(m->m.name().equals(member.memberName())&&parametersMatch(m.parameters(),call.arguments(),c) && returnMatches(m.returnType(),owner.name(),c)).findFirst().orElse(null);
@@ -18,6 +18,7 @@ final class PbsRuntimeTypes {
final Map<String, PbsAst.FunctionSignature> signatures = new HashMap<>();
final Map<String, List<PbsAst.FunctionDecl>> functions = new HashMap<>();
final Map<String, PbsAst.TypeRef> values = new HashMap<>();
final Map<String, PbsAst.ConstDecl> constants = new HashMap<>();
private final Map<String, IRRegistry.TypeDeclaration> used = new TreeMap<>();
final Map<String, PbsAst.StructDecl> structs = new LinkedHashMap<>();
final Map<String, PbsAst.ContractDecl> contracts = new LinkedHashMap<>();
@@ -52,6 +53,8 @@ final class PbsRuntimeTypes {
}
if (decl instanceof PbsAst.HostDecl h) for(var f:h.signatures()) signatures.put(h.name()+"."+f.name()+"#"+f.parameters().size(), f);
}
constants.putAll(p.studio.compiler.pbs.PbsServiceConstants.collect(ReadOnlyList.wrap(declarations)));
constants.forEach((name, constant) -> values.put(name, constant.explicitType()));
for (var imported : ast.imports()) for (var item : imported.items()) {
if (item.alias() == null || item.alias().isBlank()) continue;
aliases.put(item.alias(), item.name());
@@ -454,24 +454,36 @@ final class PbsDeclarationParser {
final var name = consume(PbsTokenKind.IDENTIFIER, "Expected service name");
consume(PbsTokenKind.LEFT_BRACE, "Expected '{' to start service body");
final var methods = new ArrayList<PbsAst.FunctionDecl>();
final var constants = new ArrayList<PbsAst.ConstDecl>();
while (!cursor.check(PbsTokenKind.RIGHT_BRACE) && !cursor.isAtEnd()) {
var methodAttributes = ReadOnlyList.<PbsAst.Attribute>empty();
if (cursor.check(PbsTokenKind.LEFT_BRACKET)) {
methodAttributes = attributeParser.parseAttributeList();
}
if (cursor.match(PbsTokenKind.DECLARE)) {
var declaration = cursor.previous();
consume(PbsTokenKind.CONST, "Expected const in service declaration");
constants.add(parseConstDeclaration(declaration, methodAttributes));
continue;
}
if (!cursor.match(PbsTokenKind.FN)) {
if (!methodAttributes.isEmpty()) {
reportAttributesNotAllowed(methodAttributes, "Attributes are valid only on service methods in service bodies");
}
report(cursor.peek(), ParseErrors.E_PARSE_INVALID_DECL_SHAPE,
"Service body accepts only method declarations");
"Service body accepts methods and declare const declarations");
cursor.advance();
continue;
}
methods.add(parseFunctionLike(cursor.previous(), methodAttributes));
if (methodAttributes.stream().anyMatch(a -> "IntrinsicCall".equals(a.name()))) {
var signature = parseFunctionSignature(cursor.previous(), methodAttributes);
methods.add(new PbsAst.FunctionDecl(signature.name(), signature.parameters(), signature.returnKind(),
signature.returnType(), signature.resultErrorType(), signature.attributes(), PbsAst.LifecycleMarker.NONE,
new PbsAst.Block(ReadOnlyList.empty(), null, signature.span()), signature.span()));
} else methods.add(parseFunctionLike(cursor.previous(), methodAttributes));
}
final var rightBrace = consume(PbsTokenKind.RIGHT_BRACE, "Expected '}' to end service body");
return new PbsAst.ServiceDecl(name.lexeme(), ReadOnlyList.wrap(methods), attributes, span(declareToken.start(), rightBrace.end()));
return new PbsAst.ServiceDecl(name.lexeme(), ReadOnlyList.wrap(methods), ReadOnlyList.wrap(constants), attributes, span(declareToken.start(), rightBrace.end()));
}
private PbsAst.ErrorDecl parseErrorDeclaration(
@@ -38,12 +38,14 @@ final class PbsAstDocumentSymbols {
return structSymbol(structDecl);
}
if (topDecl instanceof PbsAst.ServiceDecl serviceDecl) {
var members = new ArrayList<>(methodSymbols(serviceDecl.methods()));
for (var constant : serviceDecl.constants()) symbolFor(constant).ifPresent(members::add);
return namedSymbol(
serviceDecl.name(),
PbsEditorialSymbolKind.SERVICE,
"",
serviceDecl.span(),
methodSymbols(serviceDecl.methods()));
List.copyOf(members));
}
if (topDecl instanceof PbsAst.ContractDecl contractDecl) {
return namedSymbol(
@@ -30,7 +30,7 @@ final class PbsConstSemanticsValidator {
}
final var declaredType = typeOps.typeFromTypeRef(constDecl.explicitType(), model, null);
final var analysis = analyzeConstExpression(constDecl.initializer(), constByName, model, diagnostics);
final var analysis = analyzeConstExpression(constDecl.initializer(), constByName, model, diagnostics, entry.getKey().contains(".") ? entry.getKey().substring(0, entry.getKey().lastIndexOf('.')) : "", declaredType);
dependencyGraph.put(entry.getKey(), analysis.dependencies());
if (!analysis.constant()) {
@@ -55,11 +55,7 @@ final class PbsConstSemanticsValidator {
private LinkedHashMap<String, PbsAst.ConstDecl> collectConstDeclarations(final PbsAst.File ast) {
final var constByName = new LinkedHashMap<String, PbsAst.ConstDecl>();
for (final var topDecl : ast.topDecls()) {
if (topDecl instanceof PbsAst.ConstDecl constDecl) {
constByName.putIfAbsent(constDecl.name(), constDecl);
}
}
constByName.putAll(p.studio.compiler.pbs.PbsServiceConstants.collect(ast.topDecls()));
return constByName;
}
@@ -67,9 +63,10 @@ final class PbsConstSemanticsValidator {
final PbsAst.Expression expression,
final Map<String, PbsAst.ConstDecl> constByName,
final Model model,
final DiagnosticSink diagnostics) {
final DiagnosticSink diagnostics, final String owner, final TypeView expectedType) {
if (expression instanceof PbsAst.IntLiteralExpr || expression instanceof PbsAst.BoundedLiteralExpr) {
return new ConstAnalysis(TypeView.intType(), true, null, Set.of());
return new ConstAnalysis(expectedType != null && expectedType.kind() == PbsFlowSemanticSupport.Kind.LONG
? TypeView.longType() : TypeView.intType(), true, null, Set.of());
}
if (expression instanceof PbsAst.FloatLiteralExpr) {
return new ConstAnalysis(TypeView.floatType(), true, null, Set.of());
@@ -81,12 +78,13 @@ final class PbsConstSemanticsValidator {
return new ConstAnalysis(TypeView.bool(), true, null, Set.of());
}
if (expression instanceof PbsAst.GroupExpr groupExpr) {
return analyzeConstExpression(groupExpr.expression(), constByName, model, diagnostics);
return analyzeConstExpression(groupExpr.expression(), constByName, model, diagnostics, owner, expectedType);
}
if (expression instanceof PbsAst.IdentifierExpr identifierExpr) {
final var depName = identifierExpr.name();
final var depName = !owner.isEmpty() && constByName.containsKey(owner + "." + identifierExpr.name())
? owner + "." + identifierExpr.name() : identifierExpr.name();
final var depDecl = constByName.get(depName);
if (depDecl == null || depDecl.explicitType() == null || depDecl.initializer() == null) {
if (depDecl == null || depDecl.explicitType() == null) {
p.studio.compiler.source.diagnostics.Diagnostics.error(diagnostics,
PbsSemanticsErrors.E_SEM_CONST_UNRESOLVED_REFERENCE.name(),
"Const initializer references unresolved const '%s'".formatted(depName),
@@ -100,6 +98,10 @@ final class PbsConstSemanticsValidator {
Set.of(depName));
}
if (expression instanceof PbsAst.MemberExpr memberExpr) {
var path = p.studio.compiler.pbs.PbsServiceConstants.path(memberExpr);
var constant = constByName.get(path);
if (constant != null) return new ConstAnalysis(
typeOps.typeFromTypeRef(constant.explicitType(), model, null), true, null, Set.of(path));
if (memberExpr.receiver() instanceof PbsAst.IdentifierExpr enumIdentifier) {
final var cases = model.enums.get(enumIdentifier.name());
if (cases != null && cases.contains(memberExpr.memberName())) {
@@ -109,7 +111,7 @@ final class PbsConstSemanticsValidator {
return new ConstAnalysis(TypeView.unknown(), false, memberExpr.span(), Set.of());
}
if (expression instanceof PbsAst.UnaryExpr unaryExpr) {
final var operand = analyzeConstExpression(unaryExpr.expression(), constByName, model, diagnostics);
final var operand = analyzeConstExpression(unaryExpr.expression(), constByName, model, diagnostics, owner, expectedType);
if (!operand.constant()) {
return operand;
}
@@ -122,8 +124,8 @@ final class PbsConstSemanticsValidator {
return new ConstAnalysis(TypeView.unknown(), false, unaryExpr.span(), operand.dependencies());
}
if (expression instanceof PbsAst.BinaryExpr binaryExpr) {
final var left = analyzeConstExpression(binaryExpr.left(), constByName, model, diagnostics);
final var right = analyzeConstExpression(binaryExpr.right(), constByName, model, diagnostics);
final var left = analyzeConstExpression(binaryExpr.left(), constByName, model, diagnostics, owner, expectedType);
final var right = analyzeConstExpression(binaryExpr.right(), constByName, model, diagnostics, owner, expectedType);
final var deps = mergeDependencies(left.dependencies(), right.dependencies());
if (!left.constant()) {
return new ConstAnalysis(TypeView.unknown(), false, left.invalidSpan(), deps);
@@ -230,7 +232,7 @@ final class PbsConstSemanticsValidator {
}
private boolean isNumeric(final TypeView type) {
return typeOps.isInt(type) || typeOps.isFloat(type);
return typeOps.isInt(type) || type.kind() == PbsFlowSemanticSupport.Kind.LONG || typeOps.isFloat(type);
}
private boolean isArithmeticOperator(final String operator) {
@@ -232,9 +232,24 @@ public final class PbsDeclarationSemanticsValidator {
final PbsDeclarationRuleValidator rules,
final boolean interfaceModule,
final DiagnosticSink diagnostics) {
final var members = new java.util.HashSet<String>();
for (var constant : serviceDecl.constants()) {
validateDocAttributes(constant.attributes(), "service constants", diagnostics);
var missingAllowed = validateConstDeclarationAttributes(constant, interfaceModule, diagnostics);
rules.validateConstDeclaration(constant, !missingAllowed);
if (!members.add(constant.name()) || serviceDecl.methods().stream().anyMatch(m -> m.name().equals(constant.name())))
p.studio.compiler.source.diagnostics.Diagnostics.error(diagnostics,
"E_SEM_DUPLICATE_SERVICE_MEMBER", "Duplicate service member: " + constant.name(), constant.span());
}
final var methodScope = PbsCallableScope.serviceMethods(nameTable.register(serviceDecl.name()));
for (final var method : serviceDecl.methods()) {
validateDocAttributes(method.attributes(), "service methods", diagnostics);
if (method.attributes().stream().anyMatch(a -> ATTR_INTRINSIC_CALL.equals(a.name()))) {
if (!interfaceModule) reportInterfaceNonDeclarativeDecl(method.span(),
"Intrinsic service signatures are valid only in SDK interfaces", diagnostics);
validateIntrinsicCallAttributes(new PbsAst.FunctionSignature(method.name(), method.parameters(),
method.returnKind(), method.returnType(), method.resultErrorType(), method.attributes(), method.span()), diagnostics);
}
validateCallable(
methodScope,
method.name(),
@@ -757,6 +757,12 @@ public final class PbsEditorialSupportService {
}
}
} else if (receiverType.kind() == Kind.SERVICE || receiverType.kind() == Kind.CONTRACT) {
var prefix = receiverType.name() + ".";
model.serviceConstants.forEach((name, constant) -> {
if (name.startsWith(prefix)) completions.put(constant.name(), new PbsEditorialCompletionCandidate(
constant.name(), PbsEditorialSymbolKind.CONST, formatType(model.constTypes.get(name)),
receiverType.name(), Model.documentationFromAttributes(constant.attributes())));
});
final Map<String, List<CallableSymbol>> methods = receiverType.kind() == Kind.SERVICE
? Optional.ofNullable(model.services.get(receiverType.name())).map(ServiceInfo::methods).orElse(Map.of())
: Optional.ofNullable(model.contracts.get(receiverType.name())).map(ContractInfo::methods).orElse(Map.of());
@@ -864,6 +870,11 @@ public final class PbsEditorialSupportService {
}
}
if (receiverType.kind() == Kind.SERVICE || receiverType.kind() == Kind.CONTRACT) {
var key = receiverType.name() + "." + memberName;
var constant = model.serviceConstants.get(key);
if (constant != null) return Optional.of(new PbsEditorialResolvedSymbol(memberName,
PbsEditorialSymbolKind.CONST, formatType(model.constTypes.get(key)), receiverType.name(),
List.of(), Model.documentationFromAttributes(constant.attributes())));
final Map<String, List<CallableSymbol>> methods = receiverType.kind() == Kind.SERVICE
? Optional.ofNullable(model.services.get(receiverType.name())).map(ServiceInfo::methods).orElse(Map.of())
: Optional.ofNullable(model.contracts.get(receiverType.name())).map(ContractInfo::methods).orElse(Map.of());
@@ -981,6 +992,8 @@ public final class PbsEditorialSupportService {
return callableLocations(structInfo.methods().get(memberName));
}
if (receiverType.kind() == Kind.SERVICE || receiverType.kind() == Kind.CONTRACT) {
var constant = model.serviceConstants.get(receiverType.name() + "." + memberName);
if (constant != null) return locations(constant.span());
final Map<String, List<CallableSymbol>> methods = receiverType.kind() == Kind.SERVICE
? Optional.ofNullable(model.services.get(receiverType.name())).map(ServiceInfo::methods).orElse(Map.of())
: Optional.ofNullable(model.contracts.get(receiverType.name())).map(ContractInfo::methods).orElse(Map.of());
@@ -2146,7 +2159,7 @@ public final class PbsEditorialSupportService {
builtinTypeDecl.span());
}
if (topDecl instanceof PbsAst.ServiceDecl serviceDecl) {
return new PbsAst.ServiceDecl(newName, serviceDecl.methods(), serviceDecl.attributes(), serviceDecl.span());
return new PbsAst.ServiceDecl(newName, serviceDecl.methods(), serviceDecl.constants(), serviceDecl.attributes(), serviceDecl.span());
}
if (topDecl instanceof PbsAst.HostDecl hostDecl) {
return new PbsAst.HostDecl(newName, hostDecl.signatures(), hostDecl.attributes(), hostDecl.span());
@@ -172,6 +172,7 @@ final class PbsFlowBodyAnalyzer {
final DiagnosticSink diagnostics) {
final var receiverType = TypeView.service(serviceDecl.name());
for (final var method : serviceDecl.methods()) {
if (method.attributes().stream().anyMatch(a -> "IntrinsicCall".equals(a.name()))) continue;
validateCallableBody(
method.parameters(),
method.body(),
@@ -217,6 +217,8 @@ final class PbsFlowCallableResolutionAnalyzer {
if (service == null) {
return ExprResult.type(TypeView.unknown());
}
var constant = model.constTypes.get(receiver.name() + "." + memberExpr.memberName());
if (constant != null) return ExprResult.type(constant);
final var methods = service.methods().get(memberExpr.memberName());
if (methods != null && !methods.isEmpty()) {
if (use == ExprUse.VALUE) {
@@ -293,7 +295,7 @@ final class PbsFlowCallableResolutionAnalyzer {
if (compatible.isEmpty()) {
Diagnostics.error(diagnostics,
PbsSemanticsErrors.E_SEM_APPLY_UNRESOLVED_OVERLOAD.name(),
"No callable overload matches the provided argument",
"No callable overload matches the provided argument; numeric carriers require explicit conversion",
wholeSpan);
return ExprResult.type(TypeView.unknown());
}
@@ -197,6 +197,7 @@ final class PbsFlowSemanticSupport {
final Map<String, Set<String>> enums = new HashMap<>();
final Map<String, Set<String>> errors = new HashMap<>();
final Map<String, TypeView> constTypes = new HashMap<>();
final Map<String, PbsAst.ConstDecl> serviceConstants = new HashMap<>();
final Map<String, TypeView> globalTypes = new HashMap<>();
final Map<String, TypeView> serviceSingletons = new HashMap<>();
final Set<String> knownBuiltinTypeNames = new HashSet<>();
@@ -230,6 +231,11 @@ final class PbsFlowSemanticSupport {
for (final var topDecl : supplementalTopDecls) {
model.ingestTopDecl(topDecl);
}
for (var imported : ast.imports()) for (var item : imported.items()) {
if (item.alias() == null || item.alias().isBlank() || !model.services.containsKey(item.name())) continue;
model.services.put(item.alias(), model.services.get(item.name()));
model.serviceSingletons.put(item.alias(), TypeView.service(item.name()));
}
model.ingestAssetSurface(feSurfaceContext, diagnostics);
return model;
}
@@ -333,6 +339,11 @@ final class PbsFlowSemanticSupport {
method.span(),
documentationFromAttributes(method.attributes())));
}
for (var constant : serviceDecl.constants()) {
var key = serviceDecl.name() + "." + constant.name();
constTypes.put(key, typeFrom(constant.explicitType()));
serviceConstants.put(key, constant);
}
services.put(serviceDecl.name(), new ServiceInfo(methods));
serviceSingletons.put(serviceDecl.name(), TypeView.service(serviceDecl.name()));
return;
@@ -494,7 +505,7 @@ final class PbsFlowSemanticSupport {
return new CallableSymbol(name, semanticParameters, input, callableReturn(returnKind, returnType, resultErrorType), span, documentation);
}
private String documentationFromAttributes(final ReadOnlyList<PbsAst.Attribute> attributes) {
static String documentationFromAttributes(final ReadOnlyList<PbsAst.Attribute> attributes) {
for (final var attribute : attributes) {
if (!"Doc".equals(attribute.name()) || attribute.arguments().isEmpty()) {
continue;
@@ -114,6 +114,10 @@ final class PbsFlowStructuralExpressionAnalyzer {
return ExprResult.type(serviceType);
}
if (receiverType != null && receiverType.kind() == Kind.SERVICE) {
var member = model.constTypes.get(receiverType.name() + "." + identifierExpr.name());
if (member != null) return ExprResult.type(member);
}
final var constType = model.constTypes.get(identifierExpr.name());
if (constType != null) {
return ExprResult.type(constType);
@@ -87,7 +87,7 @@ final class PbsImportedSemanticContextService {
if (topDecl instanceof PbsAst.ServiceDecl serviceDecl) {
var accessor = p.studio.compiler.pbs.lowering.PbsExecutableCallableRegistryFactory.singletonAccessor(serviceDecl);
appendImportedCallable(importedCallables, importedCallableKeys,
new PbsFrontendCompiler.ImportedCallableSurface(importedModuleId, localName+".$instance", 0, 1,
new PbsFrontendCompiler.ImportedCallableSurface(importedModuleId, serviceDecl.name()+".$instance", 0, 1,
accessor.returnKind(), accessor.returnType(), frontendCompiler.callableShapeSurfaceOf(accessor)));
for (final var method : serviceDecl.methods()) {
appendImportedCallable(
@@ -95,7 +95,7 @@ final class PbsImportedSemanticContextService {
importedCallableKeys,
new PbsFrontendCompiler.ImportedCallableSurface(
importedModuleId,
localName + "." + method.name(),
serviceDecl.name() + "." + method.name(),
method.parameters().size(),
returnSlotsFor(method),
method.returnKind(),
@@ -0,0 +1,29 @@
[Doc(markdown = """
Runtime-owned numeric operations with exact carrier signatures.
""")]
declare service math {
[IntrinsicCall(name = "math.i32.min", version = 1)]
fn min(a: int, b: int) -> int;
[IntrinsicCall(name = "math.i32.max", version = 1)]
fn max(a: int, b: int) -> int;
[IntrinsicCall(name = "math.i32.clamp", version = 1)]
fn clamp(value: int, min: int, max: int) -> int;
[IntrinsicCall(name = "math.i32.abs", version = 1)]
fn abs(value: int) -> int;
[IntrinsicCall(name = "math.i32.to_i64", version = 1)]
fn to_i64(value: int) -> long;
[IntrinsicCall(name = "math.i32.to_float", version = 1)]
fn to_float(value: int) -> float;
[IntrinsicCall(name = "math.i64.min", version = 1)]
fn min(a: long, b: long) -> long;
[IntrinsicCall(name = "math.i64.max", version = 1)]
fn max(a: long, b: long) -> long;
[IntrinsicCall(name = "math.i64.clamp", version = 1)]
fn clamp(value: long, min: long, max: long) -> long;
[IntrinsicCall(name = "math.i64.abs", version = 1)]
fn abs(value: long) -> long;
[IntrinsicCall(name = "math.i64.to_i32", version = 1)]
fn to_i32(value: long) -> int;
[IntrinsicCall(name = "math.i64.to_float", version = 1)]
fn to_float(value: long) -> float;
}
@@ -0,0 +1,37 @@
[Doc(markdown = """
Runtime-owned numeric operations with exact carrier signatures.
""")]
declare service mathf {
[IntrinsicCall(name = "mathf.min", version = 1)]
fn min(a: float, b: float) -> float;
[IntrinsicCall(name = "mathf.max", version = 1)]
fn max(a: float, b: float) -> float;
[IntrinsicCall(name = "mathf.clamp", version = 1)]
fn clamp(value: float, min: float, max: float) -> float;
[IntrinsicCall(name = "mathf.abs", version = 1)]
fn abs(value: float) -> float;
[IntrinsicCall(name = "mathf.floor", version = 1)]
fn floor(value: float) -> float;
[IntrinsicCall(name = "mathf.ceil", version = 1)]
fn ceil(value: float) -> float;
[IntrinsicCall(name = "mathf.trunc", version = 1)]
fn trunc(value: float) -> float;
[IntrinsicCall(name = "mathf.round", version = 1)]
fn round(value: float) -> float;
[IntrinsicCall(name = "mathf.sqrt", version = 1)]
fn sqrt(value: float) -> float;
[IntrinsicCall(name = "mathf.sin", version = 1)]
fn sin(angle: float) -> float;
[IntrinsicCall(name = "mathf.cos", version = 1)]
fn cos(angle: float) -> float;
[IntrinsicCall(name = "mathf.atan2", version = 1)]
fn atan2(y: float, x: float) -> float;
[IntrinsicCall(name = "mathf.to_i32", version = 1)]
fn to_i32(value: float) -> int;
[IntrinsicCall(name = "mathf.to_i64", version = 1)]
fn to_i64(value: float) -> long;
[BuiltinConst(target = "mathf", name = "pi", version = 1)]
declare const pi: float;
[BuiltinConst(target = "mathf", name = "tau", version = 1)]
declare const tau: float;
}
@@ -0,0 +1,8 @@
import { math } from @sdk:math;
import { mathf as numbers } from @sdk:mathf;
fn mathExample() -> float {
let counter: long = 42;
let bounded = math.clamp(counter, 0 as long, 100 as long);
return math.to_float(bounded) + numbers.sin(0.0) + numbers.pi;
}
@@ -16,6 +16,15 @@ import static org.junit.jupiter.api.Assertions.*;
final class PbsEditorialSupportServiceTest {
private final PbsEditorialSupportService service = new PbsEditorialSupportService();
@Test void serviceConstantsHaveCompletionHoverAndDefinition() {
String source = "declare service Settings { declare const answer: int = 42; } fn main() -> int { return Settings.answer; }";
var ast = parseOrdinary(source);
int use = source.indexOf("Settings.answer");
assertTrue(service.completion(source, ast, ReadOnlyList.empty(), use+9).stream().anyMatch(c -> c.label().equals("answer") && c.kind() == PbsEditorialSymbolKind.CONST));
assertTrue(service.hover(source, ast, ReadOnlyList.empty(), use+10).isPresent());
assertFalse(service.definition(source, ast, ReadOnlyList.empty(), use+10).isEmpty());
}
@Test
void closuresExposeCapturedObjectsAndOwnParameters() {
String source = """
+29
View File
@@ -131,3 +131,32 @@ threshold collections, retained closure/object reachability after frame one,
and reclamation after release. The remaining root is the global array.
PBS publishes FRAME_ROOT and the existing guarded wrapper returns normally.
No sync syntax, new frame integration, suspension or coroutine is introduced.
## PBS service constants and runtime math
`PbsRuntimeMathTest` produces 261 independent numeric cases in both ordinary and
optimized bytecode (522 mandatory executions per runtime profile), covering all
26 math/mathf signatures. The checked-in corpus preserves 240 provider scalar
fixture rows and exact contract examples (duplicates removed); provenance is in
`prometeu-architecture-tests/src/test/resources/math/provenance.txt`.
The harness verifies exact bits/faults, selected intrinsic identity and one
retained call per case. Single-step charging is compared with the provider's
opcode costs and independent fixture call cost; full-budget charging must equal
their sum, and optimization must preserve total cycles. Additional cases exercise
pi/tau, literal sin, ordinary int/long service constants, constant dependencies,
and real module imports with service aliases. The installed example also imports
both SDK services, so installedKnowledgeTest covers their packaged resources.
```sh
./gradlew :prometeu-architecture-tests:test --tests '*PbsRuntimeMathTest'
python3 tools/pbx-conformance/run.py --runtime ../runtime --math-only
python3 tools/pbx-conformance/run.py --runtime ../runtime --math-only --release
```
Omit `--math-only` for the full existing corpus. `--release` selects the optimized
Rust runtime harness; it is independent of the PBS optimizer variants included in
every run. Optional `CARGO_TARGET_DIR` can retain build artifacts outside the
runtime checkout. Each invocation prints runtime revision, platform, profile,
features, lockfile and provider catalog/oracle hashes. Local evidence qualifies
macOS/arm64 only; macOS/x86_64 and Linux/x86_64 remain pending.
+97 -1
View File
@@ -36,6 +36,8 @@ impl NativeInterface for NoNative {
fn main() {
let root = std::path::PathBuf::from(std::env::args().nth(1).expect("fixture directory"));
verify_pbs_math_fixtures(&root);
if std::env::args().any(|arg| arg == "--math-only") { return; }
verify_catalog_fixtures(&root);
verify_pbs_fixtures(&root);
verify_pbs_structured_fixtures(&root);
@@ -475,7 +477,7 @@ fn verify_pbs_fixtures(root: &std::path::Path) {
for entry in std::fs::read_dir(root).unwrap() {
let path = entry.unwrap().path();
let name = path.file_stem().unwrap().to_str().unwrap();
if name.starts_with("pbs-structured-") || !name.starts_with("pbs-") || path.extension().and_then(|v| v.to_str()) != Some("pbx") { continue; }
if name.starts_with("pbs-math-") || name.starts_with("pbs-structured-") || !name.starts_with("pbs-") || path.extension().and_then(|v| v.to_str()) != Some("pbx") { continue; }
count += 1;
let bytes = std::fs::read(&path).unwrap();
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE)
@@ -630,3 +632,97 @@ fn verify_pbs_closure_frames(root: &std::path::Path) {
}
println!("PBS CLOSURE FRAME LIFECYCLE/RETENTION/GC PASS");
}
// The expected results/call costs are independent provider fixtures. Step costs
// use the published opcode contract, not observed timings or compiler estimates.
fn verify_pbs_math_fixtures(root: &std::path::Path) {
use prometeu_vm::LogicalFrameEndingReason as End;
use prometeu_bytecode::isa::core::CoreOpCode as OpCode;
let corpus = std::fs::read_to_string(root.join("math-vectors.tsv")).expect("mandatory math corpus");
let mut covered = std::collections::BTreeSet::new();
let mut count = 0;
let mut original_cycles = std::collections::BTreeMap::new();
let mut names = std::collections::BTreeSet::new();
for line in corpus.lines() {
let parts: Vec<_> = line.split_whitespace().collect();
let name = parts[0];
assert!(names.insert(parts[0]), "duplicate math fixture");
let id = u32::from_str_radix(parts[1], 16).unwrap();
let expected = parts[parts.len()-2];
let cost: u64 = parts.last().unwrap().parse().unwrap();
let bytes = std::fs::read(root.join(format!("{name}.pbx"))).unwrap();
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE).unwrap();
let code = image.code().to_vec();
let mut vm = VirtualMachine::from_image(image, Default::default());
vm.prepare_boot_call().unwrap();
let mut total = 0;
let mut calls = 0;
let ending = loop {
let pc = vm.pc();
let opcode = OpCode::try_from(u16::from_le_bytes(code[pc..pc+2].try_into().unwrap())).unwrap();
let cycles = if opcode == OpCode::Intrinsic {
let actual = u32::from_le_bytes(code[pc+2..pc+6].try_into().unwrap());
assert_eq!(actual, id, "{name}: wrong overload or unexpected conversion");
calls += 1;
cost
} else { opcode.cycles() };
let report = vm.run_budget(1, &mut NoNative, &mut HostContext::new(None)).unwrap();
assert_eq!(report.cycles_used, cycles, "{name}: cycle charge at {pc}, {opcode:?}");
total += cycles;
if matches!(report.reason, End::Halted | End::EndOfRom | End::Trap(_)) { break report.reason; }
assert!(total < 10000, "{name}: nonterminating source fixture");
};
assert_eq!(calls, 1, "{name}: preserve literal calls and no hidden conversions");
if let Some(code) = expected.strip_prefix("trap:") {
let code = u32::from_str_radix(code,16).unwrap();
assert!(matches!(ending, End::Trap(ref trap) if trap.code == code), "{name}: {ending:?}");
} else {
assert!(matches!(ending, End::Halted | End::EndOfRom), "{name}: {ending:?}");
let value = vm.operand_stack_top(1);
let actual = match &value[0] {
Value::Float(value) => format!("f:{:016x}",value.to_bits()),
Value::Int32(value) => format!("i:{value}"),
Value::Int64(value) => format!("l:{value}"),
value => panic!("{name}: unexpected value {value:?}"),
};
assert_eq!(actual, expected, "{name}: exact result bits");
}
// A full-budget execution must charge exactly the independently checked steps.
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE).unwrap();
let mut vm = VirtualMachine::from_image(image, Default::default());
vm.prepare_boot_call().unwrap();
let report = vm.run_budget(10000, &mut NoNative, &mut HostContext::new(None)).unwrap();
assert_eq!(report.cycles_used, total, "{name}: aggregate cost");
if let Some(original) = name.strip_suffix("-optimized") {
assert_eq!(original_cycles.get(original), Some(&total), "{name}: optimization changed cycles");
} else { original_cycles.insert(name.to_string(), total); }
covered.insert(id);
count += 1;
}
assert_eq!(covered, (0x3000..=0x3019).collect());
assert_eq!(count, 522, "mandatory boundary corpus missing");
for (name, expected) in [("pi", Value::Float(f64::from_bits(0x400921fb54442d18))),
("tau", Value::Float(f64::from_bits(0x401921fb54442d18))),
("literal", Value::Float(-0.0)), ("dependency", Value::Int32(42)), ("long", Value::Int64(2147483648)),
("service", Value::Int32(42)), ("min", Value::Int64(42))] {
let bytes = std::fs::read(root.join(format!("pbs-math-{name}.pbx"))).unwrap();
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE).unwrap();
let mut vm = VirtualMachine::from_image(image, Default::default());
vm.prepare_boot_call().unwrap();
let report = vm.run_budget(10000, &mut NoNative, &mut HostContext::new(None)).unwrap();
assert!(matches!(report.reason, End::Halted | End::EndOfRom), "{name}: {report:?}");
let actual = vm.operand_stack_top(1);
match (&actual[0], &expected) {
(Value::Float(a), Value::Float(b)) => assert_eq!(a.to_bits(), b.to_bits(), "{name}"),
_ => assert_eq!(actual, vec![expected]),
}
if name == "pi" || name == "tau" || name == "service" { assert_eq!(report.cycles_used, 6, "constant load + root RET only"); }
}
let bytes = std::fs::read(root.join("pbs-math-import.pbx")).expect("real SDK imports fixture");
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE).unwrap();
let mut vm = VirtualMachine::from_image(image, Default::default());
vm.prepare_boot_call().unwrap();
let report = vm.run_budget(10000, &mut NoNative, &mut HostContext::new(None)).unwrap();
assert!(matches!(report.reason, End::Halted | End::EndOfRom), "import: {report:?}");
println!("PBS MATH PASS: {count} exact bits/faults/cycle vectors; all 26 signatures; service constants");
}
+7 -1
View File
@@ -1,5 +1,6 @@
"""Build a production-loader harness without writing into the runtime checkout."""
import argparse
import hashlib
import json
import pathlib
import platform
@@ -10,10 +11,15 @@ parser = argparse.ArgumentParser()
parser.add_argument("--runtime", type=pathlib.Path, default=pathlib.Path("../runtime"))
parser.add_argument("--fixtures", type=pathlib.Path, default=pathlib.Path("prometeu-compiler/prometeu-build-pipeline/build/registry-conformance"))
parser.add_argument("--online", action="store_true", help="Allow Cargo to fetch uncached dependencies")
parser.add_argument("--release", action="store_true", help="Execute an optimized runtime harness")
parser.add_argument("--math-only", action="store_true", help="Run the complete PBS math corpus only")
args = parser.parse_args()
runtime = args.runtime.resolve()
print("runtime", subprocess.check_output(["git", "-C", str(runtime), "rev-parse", "HEAD"], text=True).strip(), flush=True)
print("platform", platform.platform(), "limits=default capabilities=NONE", flush=True)
print("profile", "release" if args.release else "dev", "features=resource-diagnostics", flush=True)
for relative in ["Cargo.lock", "docs/vm-arch/INTRINSICS.csv", "docs/vm-arch/BUILTIN_CONSTANTS.csv", "crates/console/prometeu-vm/tests/fixtures/numeric-conformance.tsv"]:
print("sha256", relative, hashlib.sha256((runtime / relative).read_bytes()).hexdigest(), flush=True)
with tempfile.TemporaryDirectory(prefix="pbx-conformance-") as directory:
root = pathlib.Path(directory)
manifest = '[package]\nname="studio-pbx-conformance"\nversion="0.1.0"\nedition="2024"\n[dependencies]\n'
@@ -25,4 +31,4 @@ with tempfile.TemporaryDirectory(prefix="pbx-conformance-") as directory:
(root / "Cargo.lock").write_text((runtime / "Cargo.lock").read_text())
(root / "src").mkdir()
(root / "src/main.rs").write_text(pathlib.Path(__file__).with_name("main.rs").read_text())
subprocess.run(["cargo", "run", *([] if args.online else ["--offline"]), "--manifest-path", str(root / "Cargo.toml"), "--", str(args.fixtures.resolve()), str(runtime / "devtools/headless-protocol/response.schema.json")], check=True)
subprocess.run(["cargo", "run", *(["--release"] if args.release else []), *([] if args.online else ["--offline"]), "--manifest-path", str(root / "Cargo.toml"), "--", str(args.fixtures.resolve()), str(runtime / "devtools/headless-protocol/response.schema.json"), *(["--math-only"] if args.math_only else [])], check=True)