04fa9844f4
Four defects found by dogfooding Speckl against the v0.3 product-layer spec (FederatedMeetupProduct.speckdl, 74 members): D1 — CRITICAL: List<T> fields in interface records emitted empty type Root cause: interface record fields called speckTypeToProto(f.type.name) which returns '' for List/Map/Set types (their .name is undefined). Event and state fields had inline List/Map dispatch, but interfaces did not. Fix: extracted typeExprToProto() shared function that handles all TypeExpr variants (primitive, ident, list, map, set). All four field-emitting code paths (interfaces, events, state, transitions) now use it. D2 — MODERATE: Transition type discriminator field silently dropped Root cause: parser stores the type field in t.typeDiscriminator (string) rather than in t.fields array. Generator only emitted t.fields. Fix: emit typeDiscriminator as 'type' field at number 1, offset other fields by 1 to avoid collision. D4 — LOW: Enum variant name collisions across enums in same proto scope Proto3 requires all enum values unique within enclosing scope, not just the enum. PENDING in Role and PENDING in OrderStatus collided. Fix: prefix all variants with upperSnake(enumName) — the proto3 convention. This also matches the handwritten proto's naming (TRANSITION_TYPE_*). D5 — LOW: Date in interface fields did not trigger timestamp import The usesTimestamp check only scanned events and state, not interfaces. Fix: added interface member check to the timestamp import scan. D3 (deferred): rc_ typo in spec source silently swallowed by parser. Parser bug, not generator bug. Filed for future cycle. Verified: 56/56 tests pass, both FederatedMeetup.speckdl and FederatedMeetupProduct.speckdl compile to protoc-clean output.
1498 lines
No EOL
60 KiB
JavaScript
1498 lines
No EOL
60 KiB
JavaScript
import fs from 'fs';
|
|
/**
|
|
* Parse a .speck file and return the AST
|
|
*/
|
|
export function parseSpeckFile(filePath) {
|
|
const content = fs.readFileSync(filePath, 'utf-8');
|
|
return parseSpeckContent(content, filePath);
|
|
}
|
|
/**
|
|
* Parse SpeckDL content and return the AST
|
|
*/
|
|
export function parseSpeckContent(content, filePath) {
|
|
const specks = [];
|
|
const lines = content.split('\n');
|
|
let i = 0;
|
|
while (i < lines.length) {
|
|
const line = lines[i].trim();
|
|
// Skip empty lines and comments
|
|
if (!line || line.startsWith('//') || line.startsWith('/*')) {
|
|
i++;
|
|
continue;
|
|
}
|
|
// Handle import statements
|
|
if (line.startsWith('import ')) {
|
|
const importNode = parseImportStatement(line);
|
|
// Import is a special case - it's not part of a speck
|
|
// We'll handle it separately in a future update
|
|
i++;
|
|
continue;
|
|
}
|
|
// Handle speck definitions
|
|
if (line.startsWith('speck ')) {
|
|
const speck = parseSpeck(lines, i);
|
|
if (speck) {
|
|
specks.push(speck);
|
|
// Move index past the speck we just parsed
|
|
i++; // Increment by 1, the loop will continue from next line
|
|
}
|
|
else {
|
|
i++;
|
|
}
|
|
continue;
|
|
}
|
|
i++;
|
|
}
|
|
return { specks };
|
|
}
|
|
function parseSpeck(lines, startIndex) {
|
|
const headerMatch = lines[startIndex].match(/^speck\s+([\w-]+)\s*{/);
|
|
if (!headerMatch)
|
|
return null;
|
|
const name = headerMatch[1];
|
|
const members = [];
|
|
// Cycle 61: clear static metadata fields at the start of each parse
|
|
// so per-speck directives don't leak between parse calls. This is the
|
|
// pre-existing static-field-hack pattern for proto_package / go_package
|
|
// (see spec-compiler-dogfood skill anti-pattern). Refactoring to a
|
|
// local-object approach is tracked as a separate cleanup; for now
|
|
// resetting the fields here is the minimal-touch fix.
|
|
parseSpeck._protoPackage = undefined;
|
|
parseSpeck._goPackage = undefined;
|
|
parseSpeck._eventSuffix = undefined;
|
|
let i = startIndex + 1;
|
|
let braceCount = 1;
|
|
while (i < lines.length && braceCount > 0) {
|
|
const rawLine = lines[i];
|
|
const line = rawLine.trim();
|
|
if (!line || line.startsWith('//') || line.startsWith('/*')) {
|
|
i++;
|
|
continue;
|
|
}
|
|
// ── Top-of-file protobuf metadata directives ────────────────
|
|
// These attach to the SpeckNode and are NOT emitted as members.
|
|
// Format: `key: value` (string values may be quoted or bare).
|
|
// `author:`, `version:`, `license:` continue to be parsed as members
|
|
// (AuthorNode, etc.) for backward compatibility with the existing
|
|
// PROV-O / CycloneDX generators.
|
|
const metaMatch = line.match(/^(proto_package|go_package|event_suffix)\s*:\s*(.+)$/);
|
|
if (metaMatch) {
|
|
// Strip surrounding quotes if present
|
|
const value = metaMatch[2].trim().replace(/^['"]|['"]$/g, '');
|
|
if (metaMatch[1] === 'proto_package') {
|
|
parseSpeck._protoPackage = value;
|
|
}
|
|
else if (metaMatch[1] === 'go_package') {
|
|
parseSpeck._goPackage = value;
|
|
}
|
|
else if (metaMatch[1] === 'event_suffix') {
|
|
parseSpeck._eventSuffix = value;
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
// Count braces on this line first
|
|
const openCount = (rawLine.match(/{/g) || []).length;
|
|
const closeCount = (rawLine.match(/}/g) || []).length;
|
|
// Check for block-opening members (those that open braces on the same line)
|
|
const blockStarters = ['state:', 'init:', 'action ', 'event ', 'provenance ', 'bom ', 'interface ',
|
|
'state {', 'init {', 'verify ', 'constraint ', 'input:', 'output:', 'service ', 'oneof ', 'transition ',
|
|
'state as '];
|
|
const isBlockStarter = blockStarters.some(s => line.startsWith(s));
|
|
if (isBlockStarter && openCount > 0) {
|
|
// Multi-line block: parse it and skip to its end
|
|
const member = parseMemberBlock(lines, i);
|
|
if (member) {
|
|
members.push(member);
|
|
}
|
|
// Skip past this block if it spans multiple lines
|
|
if (closeCount < openCount) {
|
|
const endIdx = findBlockEnd(lines, i + 1, braceCount + openCount);
|
|
i = endIdx + 1;
|
|
}
|
|
else {
|
|
i++;
|
|
}
|
|
continue;
|
|
}
|
|
// Handle constraint/verify blocks that may span multiple lines without braces
|
|
// (e.g. constraint Name: forall r in [0..4]:, verify: always(implies(\n ...\n)))
|
|
if (line.startsWith('constraint ') || line.startsWith('verify ') || line.startsWith('verify:')) {
|
|
const member = parseMultiLineConstraintVerify(lines, i);
|
|
if (member) {
|
|
members.push(member);
|
|
// Skip past the consumed continuation lines
|
|
while (i + 1 < lines.length) {
|
|
const nextLine = lines[i + 1].trim();
|
|
if (!nextLine || nextLine.startsWith('//') || nextLine.startsWith('/*') ||
|
|
nextLine.startsWith('constraint ') || nextLine.startsWith('verify ') ||
|
|
nextLine.startsWith('constraint:') || nextLine.startsWith('verify:') ||
|
|
nextLine.startsWith('state') || nextLine.startsWith('init') ||
|
|
nextLine.startsWith('action ') || nextLine.startsWith('event ') ||
|
|
nextLine.startsWith('interface ') || nextLine.startsWith('provenance ') ||
|
|
nextLine.startsWith('service ') || nextLine.startsWith('bom ') ||
|
|
nextLine.startsWith('}') ||
|
|
nextLine.startsWith('next:') || nextLine.startsWith('invariant ')) {
|
|
break;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
// Single-line: update brace count, then parse if still inside
|
|
braceCount += openCount - closeCount;
|
|
if (braceCount <= 0) {
|
|
i++;
|
|
break;
|
|
}
|
|
const member = parseMember(line);
|
|
if (member) {
|
|
members.push(member);
|
|
}
|
|
i++;
|
|
}
|
|
return { type: 'speck', name, members,
|
|
protoPackage: parseSpeck._protoPackage,
|
|
goPackage: parseSpeck._goPackage,
|
|
eventSuffix: parseSpeck._eventSuffix };
|
|
}
|
|
function findBlockEnd(lines, startIndex, startBraceCount) {
|
|
let braceCount = startBraceCount;
|
|
let i = startIndex;
|
|
while (i < lines.length) {
|
|
const line = lines[i];
|
|
for (const ch of line) {
|
|
if (ch === '{')
|
|
braceCount++;
|
|
if (ch === '}') {
|
|
braceCount--;
|
|
if (braceCount < startBraceCount) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
return i;
|
|
}
|
|
// Check if an expression has balanced braces, parens, and brackets
|
|
function isExpressionComplete(expr) {
|
|
let braces = 0, parens = 0, brackets = 0;
|
|
for (const char of expr) {
|
|
if (char === '{')
|
|
braces++;
|
|
else if (char === '}')
|
|
braces--;
|
|
else if (char === '(')
|
|
parens++;
|
|
else if (char === ')')
|
|
parens--;
|
|
else if (char === '[')
|
|
brackets++;
|
|
else if (char === ']')
|
|
brackets--;
|
|
}
|
|
return braces === 0 && parens === 0 && brackets === 0;
|
|
}
|
|
function parseMemberBlock(lines, startIndex) {
|
|
const firstLine = lines[startIndex].trim();
|
|
const startBraceCount = (firstLine.match(/{/g) || []).length;
|
|
if (firstLine.startsWith('state:')) {
|
|
return parseStateBlockMultiline(lines, startIndex, startBraceCount);
|
|
}
|
|
if (firstLine.startsWith('state {') || firstLine === 'state') {
|
|
return parseStateBlockMultiline(lines, startIndex, startBraceCount);
|
|
}
|
|
if (firstLine.startsWith('state as ')) {
|
|
// Cycle 63: `state as <MessageName> { ... }` form must dispatch
|
|
// through the same state-block parser so the `as` override on the
|
|
// first line is captured.
|
|
return parseStateBlockMultiline(lines, startIndex, startBraceCount);
|
|
}
|
|
if (firstLine.startsWith('init:')) {
|
|
return parseInitBlockMultiline(lines, startIndex, startBraceCount);
|
|
}
|
|
if (firstLine.startsWith('init {') || firstLine === 'init') {
|
|
return parseInitBlockMultiline(lines, startIndex, startBraceCount);
|
|
}
|
|
if (firstLine.startsWith('action ')) {
|
|
return parseActionBlockMultiline(lines, startIndex, startBraceCount);
|
|
}
|
|
if (firstLine.startsWith('event ')) {
|
|
return parseEventBlockMultiline(lines, startIndex, startBraceCount);
|
|
}
|
|
if (firstLine.startsWith('interface ')) {
|
|
return parseInterfaceBlockMultiline(lines, startIndex, startBraceCount);
|
|
}
|
|
if (firstLine.startsWith('oneof ')) {
|
|
return parseOneofBlockMultiline(lines, startIndex, startBraceCount);
|
|
}
|
|
if (firstLine.startsWith('transition ')) {
|
|
return parseTransitionBlockMultiline(lines, startIndex, startBraceCount);
|
|
}
|
|
if (firstLine.startsWith('service ')) {
|
|
return parseServiceBlockMultiline(lines, startIndex, startBraceCount);
|
|
}
|
|
if (firstLine.startsWith('provenance ')) {
|
|
return { type: 'provenance', clauses: [] };
|
|
}
|
|
if (firstLine.startsWith('bom ')) {
|
|
return { type: 'bom' };
|
|
}
|
|
if (firstLine.startsWith('verify ')) {
|
|
return parseVerifyBlockMultiline(lines, startIndex, startBraceCount);
|
|
}
|
|
if (firstLine.startsWith('constraint ')) {
|
|
return parseConstraintBlockMultiline(lines, startIndex, startBraceCount);
|
|
}
|
|
if (firstLine.startsWith('input:') || firstLine.startsWith('output:')) {
|
|
return parseInputOutputBlock(lines, startIndex, startBraceCount);
|
|
}
|
|
return null;
|
|
}
|
|
/**
|
|
* Parse a multi-line `input: { ... }` or `output: { ... }` block.
|
|
*
|
|
* The first line opens with `input: {` or `output: {` and the matching `}`
|
|
* may be many lines later (with field declarations on intermediate lines).
|
|
* We collect all lines up to the matching `}` (brace-counted) and join the
|
|
* inner content into a single record string that `parseTypeExpr` already
|
|
* knows how to handle.
|
|
*/
|
|
function parseInputOutputBlock(lines, startIndex, startBraceCount) {
|
|
const header = lines[startIndex].trim();
|
|
const isInput = header.startsWith('input:');
|
|
const kind = isInput ? 'input' : 'output';
|
|
// Collect inner content lines, brace-counting across the block.
|
|
// startBraceCount is the brace count on the header line (1 for `input: {`).
|
|
// We need to find the line where braceCount returns to 0 (i.e. the closing `}`).
|
|
const innerLines = [];
|
|
let braceCount = 0;
|
|
let i = startIndex;
|
|
// First pass: extract inner content from header line (everything after the first `{`).
|
|
const headerLine = lines[startIndex].trim();
|
|
const headerNoComment = headerLine.replace(/\/\/.*$/, '').trim();
|
|
const openIdx = headerNoComment.indexOf('{');
|
|
if (openIdx >= 0) {
|
|
const after = headerNoComment.substring(openIdx + 1).trim();
|
|
if (after)
|
|
innerLines.push(after);
|
|
}
|
|
braceCount = 1; // we're inside one `{` from the header
|
|
i = startIndex + 1;
|
|
while (i < lines.length && braceCount > 0) {
|
|
const raw = lines[i];
|
|
const stripped = raw.trim();
|
|
// Strip line comments (//...) — they cannot be inside a type expression.
|
|
const noComment = stripped.replace(/\/\/.*$/, '').trim();
|
|
for (const ch of noComment) {
|
|
if (ch === '{')
|
|
braceCount++;
|
|
else if (ch === '}')
|
|
braceCount--;
|
|
}
|
|
if (braceCount > 0 && noComment) {
|
|
// Inside the block — keep content (skip the closing `}` line itself).
|
|
innerLines.push(noComment);
|
|
}
|
|
i++;
|
|
}
|
|
// Join inner content with newlines; `parseTypeExpr`'s record branch
|
|
// splits on commas and matches `name: type` pairs.
|
|
const recordExpr = '{ ' + innerLines.join(' ') + ' }';
|
|
const typeExpr = parseTypeExpr(recordExpr);
|
|
return { type: kind, typeExpr };
|
|
}
|
|
function parseMember(line) {
|
|
// input:
|
|
if (line.startsWith('input:')) {
|
|
const typeExpr = parseTypeExpr(line.substring(6).trim());
|
|
return { type: 'input', typeExpr };
|
|
}
|
|
// output:
|
|
if (line.startsWith('output:')) {
|
|
const typeExpr = parseTypeExpr(line.substring(7).trim());
|
|
return { type: 'output', typeExpr };
|
|
}
|
|
// constraint Name: expr (single-line named constraint)
|
|
if (line.startsWith('constraint ')) {
|
|
const match = line.match(/^constraint\s+(\w+):\s*(.+)$/);
|
|
if (match) {
|
|
return { type: 'constraint', name: match[1], expr: match[2].trim() };
|
|
}
|
|
return null; // multi-line constraint block (handled by parseMemberBlock)
|
|
}
|
|
// constraint: expr (unnamed, single-line)
|
|
if (line.startsWith('constraint:')) {
|
|
return { type: 'constraint', expr: line.substring(11).trim() };
|
|
}
|
|
// verify Always(Name) { depth N } or verify Always(Name) (single-line forms)
|
|
if (line.startsWith('verify ')) {
|
|
return parseVerifySingleLine(line);
|
|
}
|
|
// verify: expr (old unnamed single-line)
|
|
if (line.startsWith('verify:')) {
|
|
return { type: 'verify', name: 'unnamed', temporalExpr: line.substring(7).trim() };
|
|
}
|
|
// interface:
|
|
if (line.startsWith('interface ')) {
|
|
return parseInterface(line);
|
|
}
|
|
// event:
|
|
if (line.startsWith('event ')) {
|
|
return parseEvent(line);
|
|
}
|
|
// oneof:
|
|
if (line.startsWith('oneof ')) {
|
|
return parseOneof(line);
|
|
}
|
|
// transition:
|
|
if (line.startsWith('transition ')) {
|
|
return parseTransition(line);
|
|
}
|
|
// provenance {
|
|
if (line.startsWith('provenance ')) {
|
|
return { type: 'provenance', clauses: [] };
|
|
}
|
|
// review:
|
|
if (line.startsWith('review:')) {
|
|
const kind = line.substring(7).trim();
|
|
return { type: 'review', kind };
|
|
}
|
|
// derives from:
|
|
if (line.startsWith('derives from ')) {
|
|
return parseDerives(line);
|
|
}
|
|
// satisfies:
|
|
if (line.startsWith('satisfies ')) {
|
|
return parseSatisfies(line);
|
|
}
|
|
// author:
|
|
if (line.startsWith('author:')) {
|
|
return parseAuthor(line);
|
|
}
|
|
// source:
|
|
if (line.startsWith('source:')) {
|
|
return parseSource(line);
|
|
}
|
|
// state: or state {
|
|
if (line.startsWith('state:')) {
|
|
const varsStr = line.substring(6).trim();
|
|
// state: { ... } - single-line form
|
|
if (varsStr.startsWith('{') && varsStr.endsWith('}')) {
|
|
const inner = varsStr.slice(1, -1).trim();
|
|
return parseStateBlock(inner);
|
|
}
|
|
// state: { - multi-line opening (handled by parseStateMultiline)
|
|
return { type: 'state', variables: [] };
|
|
}
|
|
if (line.startsWith('state {') || line === 'state') {
|
|
// state { ... } inline or state { on its own line (handled by parseMemberBlock)
|
|
if (line.startsWith('state {')) {
|
|
const inner = line.substring(6).trim();
|
|
const content = inner.startsWith('{') ? inner.slice(1).trim() : inner;
|
|
if (content.endsWith('}')) {
|
|
return parseStateBlock(content.slice(0, -1).trim());
|
|
}
|
|
}
|
|
return { type: 'state', variables: [] };
|
|
}
|
|
// init: or init {
|
|
if (line.startsWith('init:')) {
|
|
const initStr = line.substring(5).trim();
|
|
if (initStr.startsWith('{') && initStr.endsWith('}')) {
|
|
const inner = initStr.slice(1, -1).trim();
|
|
return parseInitBlock(inner);
|
|
}
|
|
return { type: 'init', assignments: [] };
|
|
}
|
|
if (line.startsWith('init {') || line === 'init') {
|
|
// init { ... } inline
|
|
if (line.startsWith('init {')) {
|
|
const inner = line.substring(5).trim();
|
|
const content = inner.startsWith('{') ? inner.slice(1).trim() : inner;
|
|
if (content.endsWith('}')) {
|
|
return parseInitBlock(content.slice(0, -1).trim());
|
|
}
|
|
}
|
|
return { type: 'init', assignments: [] };
|
|
}
|
|
// action keyword
|
|
if (line.startsWith('action ')) {
|
|
return parseActionHeader(line);
|
|
}
|
|
// bom {
|
|
if (line.startsWith('bom ')) {
|
|
// Simplified - full BOM block parsing would need multi-line context
|
|
return {
|
|
type: 'bom',
|
|
};
|
|
}
|
|
return null;
|
|
}
|
|
function parseStateBlock(inner) {
|
|
const variables = [];
|
|
if (!inner.trim())
|
|
return { type: 'state', variables };
|
|
const varStrs = inner.split(/;|\n/).map(s => s.trim()).filter(Boolean);
|
|
for (const vStr of varStrs) {
|
|
const withDefault = vStr.match(/^(\w+)\s*:\s*(.+?)\s*:=\s*(.+)$/);
|
|
if (withDefault) {
|
|
// Strip trailing comments from type expression
|
|
let typeStr = withDefault[2].trim();
|
|
const commentIdx = typeStr.indexOf('//');
|
|
if (commentIdx >= 0)
|
|
typeStr = typeStr.substring(0, commentIdx).trim();
|
|
variables.push({
|
|
name: withDefault[1],
|
|
typeExpr: parseTypeExpr(typeStr),
|
|
defaultInit: withDefault[3].trim(),
|
|
});
|
|
continue;
|
|
}
|
|
const withoutDefault = vStr.match(/^(\w+)\s*:\s*(.+)$/);
|
|
if (withoutDefault) {
|
|
// Strip trailing comments from type expression
|
|
let typeStr = withoutDefault[2].trim();
|
|
const commentIdx = typeStr.indexOf('//');
|
|
if (commentIdx >= 0)
|
|
typeStr = typeStr.substring(0, commentIdx).trim();
|
|
variables.push({
|
|
name: withoutDefault[1],
|
|
typeExpr: parseTypeExpr(typeStr),
|
|
});
|
|
}
|
|
}
|
|
return { type: 'state', variables };
|
|
}
|
|
function parseInitBlock(inner) {
|
|
const assignments = [];
|
|
if (!inner.trim())
|
|
return { type: 'init', assignments };
|
|
const assignStrs = inner.split(/;|\n/).map(s => s.trim()).filter(Boolean);
|
|
for (const aStr of assignStrs) {
|
|
const match = aStr.match(/^(\w+)\s*:=\s*(.+)$/);
|
|
if (match) {
|
|
assignments.push({ name: match[1], expr: match[2].trim() });
|
|
}
|
|
}
|
|
return { type: 'init', assignments };
|
|
}
|
|
function parseActionHeader(line) {
|
|
const match = line.match(/^action\s+(\w+)\s*(?:\(([^)]*)\))?\s*\{/);
|
|
if (!match)
|
|
return null;
|
|
const name = match[1];
|
|
const paramsStr = match[2] || '';
|
|
const params = [];
|
|
if (paramsStr.trim()) {
|
|
const paramPairs = paramsStr.split(',').map(s => s.trim()).filter(Boolean);
|
|
for (const p of paramPairs) {
|
|
const pMatch = p.match(/^(\w+)\s*:\s*(.+)$/);
|
|
if (pMatch) {
|
|
params.push({ name: pMatch[1], type: parseTypeExpr(pMatch[2].trim()) });
|
|
}
|
|
}
|
|
}
|
|
return { type: 'action', name, params, statements: [] };
|
|
}
|
|
function parseImportStatement(line) {
|
|
const match = line.match(/^import\s+(['"])(.+?)\1(?:\s+as\s+(\w+))?(?:\s+version\s+(['"])(.+?)\4)?(?:\s+hash\s+(['"])(.+?)\6)?/);
|
|
if (!match) {
|
|
throw new Error(`Failed to parse import statement: ${line}`);
|
|
}
|
|
const [, , path, , alias, , version, , hash] = match;
|
|
return {
|
|
type: 'import',
|
|
path,
|
|
alias,
|
|
version: version || undefined,
|
|
hash: hash || undefined,
|
|
};
|
|
}
|
|
function parseTypeExpr(expr) {
|
|
expr = expr.trim();
|
|
// Primitive types
|
|
const primitives = ['Nat', 'Int', 'Real', 'Bool', 'String', 'Bytes'];
|
|
if (primitives.includes(expr)) {
|
|
return { type: 'primitive', name: expr };
|
|
}
|
|
// List<T>
|
|
if (expr.startsWith('List<') && expr.endsWith('>')) {
|
|
const inner = expr.substring(5, expr.length - 1).trim();
|
|
return { type: 'list', elementType: parseTypeExpr(inner) };
|
|
}
|
|
// Set<T>
|
|
if (expr.startsWith('Set<') && expr.endsWith('>')) {
|
|
const inner = expr.substring(4, expr.length - 1).trim();
|
|
return { type: 'set', elementType: parseTypeExpr(inner) };
|
|
}
|
|
// Map<K, V>
|
|
if (expr.startsWith('Map<') && expr.endsWith('>')) {
|
|
const inner = expr.substring(4, expr.length - 1);
|
|
// Find the first-level comma (not inside nested generics or record literals)
|
|
let depth = 0;
|
|
let braceDepth = 0;
|
|
let commaIdx = -1;
|
|
for (let i = 0; i < inner.length; i++) {
|
|
if (inner[i] === '<' || inner[i] === '(')
|
|
depth++;
|
|
else if (inner[i] === '>' || inner[i] === ')')
|
|
depth--;
|
|
else if (inner[i] === '{')
|
|
braceDepth++;
|
|
else if (inner[i] === '}')
|
|
braceDepth--;
|
|
else if (inner[i] === ',' && depth === 0 && braceDepth === 0) {
|
|
commaIdx = i;
|
|
break;
|
|
}
|
|
}
|
|
if (commaIdx !== -1) {
|
|
const keyStr = inner.substring(0, commaIdx).trim();
|
|
const valStr = inner.substring(commaIdx + 1).trim();
|
|
return { type: 'map', keyType: parseTypeExpr(keyStr), valueType: parseTypeExpr(valStr) };
|
|
}
|
|
// Fallback: treat as ident if malformed
|
|
return { type: 'ident', name: expr };
|
|
}
|
|
// List(T) — parenthetical syntax (SpeckDL canonical form)
|
|
if (expr.startsWith('List(') && expr.endsWith(')')) {
|
|
const inner = expr.substring(5, expr.length - 1).trim();
|
|
return { type: 'list', elementType: parseTypeExpr(inner) };
|
|
}
|
|
// Set(T) — parenthetical syntax (SpeckDL canonical form)
|
|
if (expr.startsWith('Set(') && expr.endsWith(')')) {
|
|
const inner = expr.substring(4, expr.length - 1).trim();
|
|
return { type: 'set', elementType: parseTypeExpr(inner) };
|
|
}
|
|
// Map(K, V) — parenthetical syntax (SpeckDL canonical form)
|
|
if (expr.startsWith('Map(') && expr.endsWith(')')) {
|
|
const inner = expr.substring(4, expr.length - 1);
|
|
let depth = 0;
|
|
let braceDepth = 0;
|
|
let commaIdx = -1;
|
|
for (let i = 0; i < inner.length; i++) {
|
|
if (inner[i] === '(' || inner[i] === '<')
|
|
depth++;
|
|
else if (inner[i] === ')' || inner[i] === '>')
|
|
depth--;
|
|
else if (inner[i] === '{')
|
|
braceDepth++;
|
|
else if (inner[i] === '}')
|
|
braceDepth--;
|
|
else if (inner[i] === ',' && depth === 0 && braceDepth === 0) {
|
|
commaIdx = i;
|
|
break;
|
|
}
|
|
}
|
|
if (commaIdx !== -1) {
|
|
const keyStr = inner.substring(0, commaIdx).trim();
|
|
const valStr = inner.substring(commaIdx + 1).trim();
|
|
return { type: 'map', keyType: parseTypeExpr(keyStr), valueType: parseTypeExpr(valStr) };
|
|
}
|
|
// Fallback: treat as ident if malformed
|
|
return { type: 'ident', name: expr };
|
|
}
|
|
// List type: [T]
|
|
if (expr.startsWith('[') && expr.endsWith(']')) {
|
|
const elementType = parseTypeExpr(expr.substring(1, expr.length - 1));
|
|
return { type: 'list', elementType };
|
|
}
|
|
// Record type: { ... }
|
|
if (expr.startsWith('{') && expr.endsWith('}')) {
|
|
const content = expr.substring(1, expr.length - 1).trim();
|
|
const fields = [];
|
|
if (content) {
|
|
// Split by comma and parse each field
|
|
const fieldStrs = content.split(',').map(s => s.trim());
|
|
for (const fieldStr of fieldStrs) {
|
|
const fieldMatch = fieldStr.match(/^(\w+)\s*:\s*(.+)$/);
|
|
if (fieldMatch) {
|
|
const [, name, typeStr] = fieldMatch;
|
|
fields.push({ name, type: parseTypeExpr(typeStr.trim()) });
|
|
}
|
|
}
|
|
}
|
|
return { type: 'record', fields };
|
|
}
|
|
// Identifier (for interface references, etc.)
|
|
return { type: 'ident', name: expr };
|
|
}
|
|
function parseInterface(line) {
|
|
// interface Name {
|
|
const match = line.match(/^interface\s+(\w+)\s*{/);
|
|
if (!match) {
|
|
throw new Error(`Failed to parse interface: ${line}`);
|
|
}
|
|
const name = match[1];
|
|
// Header-only; parseInterfaceBlockMultiline fills in methods/fields/kind
|
|
// by scanning the lines inside the { ... } block.
|
|
return {
|
|
type: 'interface',
|
|
name,
|
|
kind: 'mixed',
|
|
methods: [],
|
|
fields: [],
|
|
};
|
|
}
|
|
function parseEvent(line) {
|
|
// event Name {
|
|
const match = line.match(/^event\s+(\w+)\s*{/);
|
|
if (!match) {
|
|
throw new Error(`Failed to parse event: ${line}`);
|
|
}
|
|
const name = match[1];
|
|
return {
|
|
type: 'event',
|
|
name,
|
|
fields: [],
|
|
};
|
|
}
|
|
// Cycle 57: parse `oneof Name {` (header only; parseOneofBlockMultiline fills variants).
|
|
function parseOneof(line) {
|
|
// oneof Name {
|
|
const match = line.match(/^oneof\s+(\w+)\s*{/);
|
|
if (!match) {
|
|
throw new Error(`Failed to parse oneof: ${line}`);
|
|
}
|
|
return {
|
|
type: 'oneof',
|
|
name: match[1],
|
|
variants: [],
|
|
};
|
|
}
|
|
// Cycle 58: parse `transition Name {` (header only; parseTransitionBlockMultiline fills fields + payload-oneof).
|
|
function parseTransition(line) {
|
|
// transition Name {
|
|
const match = line.match(/^transition\s+(\w+)\s*{/);
|
|
if (!match) {
|
|
throw new Error(`Failed to parse transition: ${line}`);
|
|
}
|
|
return {
|
|
type: 'transition',
|
|
name: match[1],
|
|
fields: [],
|
|
};
|
|
}
|
|
function parseProvenanceBlock(lines, line) {
|
|
// This is a simplified parser - in a real implementation, we'd parse the full block
|
|
return {
|
|
type: 'provenance',
|
|
clauses: [],
|
|
};
|
|
}
|
|
function parseDerives(line) {
|
|
// derives from Name via "rationale"
|
|
const match = line.match(/^derives\s+from\s+(\w+(?:-\w+)*)(?:\s+via\s+(['"])(.+?)\2)?/);
|
|
if (!match) {
|
|
console.warn(`Failed to parse derives statement: ${line}`);
|
|
return { type: 'derives', from: 'unknown' };
|
|
}
|
|
const [, from, , via] = match;
|
|
return {
|
|
type: 'derives',
|
|
from,
|
|
via: via || undefined,
|
|
};
|
|
}
|
|
function parseSatisfies(line) {
|
|
// satisfies Name [clause "X.Y.Z"]
|
|
// e.g., satisfies RESILIENCE-REQ-01 clause "3.1.2"
|
|
// e.g., satisfies RESILIENCE-REQ-02
|
|
const match = line.match(/^satisfies\s+([\w-]+(?:-[\w]+)*)(?:\s+clause\s+(['"])(.+?)\2)?/);
|
|
if (!match) {
|
|
console.warn(`Failed to parse satisfies statement: ${line}`);
|
|
return { type: 'satisfies', requirement: 'unknown' };
|
|
}
|
|
const [, requirement, , clause] = match;
|
|
return {
|
|
type: 'satisfies',
|
|
requirement,
|
|
clause: clause || undefined,
|
|
};
|
|
}
|
|
function parseAuthor(line) {
|
|
// author: "Name" <"email">
|
|
// e.g., author: "Scott Scoble" <"scott@scoble.me">
|
|
const match = line.match(/^author:\s+(['"])(.+?)\1(?:\s+<(['"])(.+?)\3>)?/);
|
|
if (!match) {
|
|
// Try without angle brackets or with different format
|
|
console.warn(`Failed to parse author statement: ${line}`);
|
|
return { type: 'author', name: 'unknown' };
|
|
}
|
|
const [, , name, , email] = match;
|
|
return {
|
|
type: 'author',
|
|
name,
|
|
email: email || undefined,
|
|
};
|
|
}
|
|
function parseSource(line) {
|
|
// source: kind ref "identifier"
|
|
// e.g., source: architecture_review ref "AR-2024-0215"
|
|
const match = line.match(/^source:\s+(\w+)(?:\s+ref\s+(['"])(.+?)\2)?/);
|
|
if (!match) {
|
|
console.warn(`Failed to parse source statement: ${line}`);
|
|
return { type: 'source', kind: 'document' };
|
|
}
|
|
const [, kind, , ref] = match;
|
|
const validKinds = [
|
|
'conversation', 'meeting', 'document', 'regulation',
|
|
'architecture_review', 'threat_model', 'compliance_audit'
|
|
];
|
|
if (!validKinds.includes(kind)) {
|
|
console.warn(`Invalid source kind: ${kind}, defaulting to document`);
|
|
return { type: 'source', kind: 'document', ref: ref || undefined };
|
|
}
|
|
return {
|
|
type: 'source',
|
|
kind: kind,
|
|
ref: ref || undefined,
|
|
};
|
|
}
|
|
function parseStateBlockMultiline(lines, startIndex, startBraceCount) {
|
|
// Cycle 59: support `state as <MessageName> { ... }` to override the
|
|
// generated .proto message name. Default (no `as`) keeps the existing
|
|
// `message <SpeckName>State { ... }` convention.
|
|
const headerLine = lines[startIndex].trim();
|
|
const asMatch = headerLine.match(/^state\s+as\s+(\w+)\s*{/);
|
|
const messageName = asMatch ? asMatch[1] : undefined;
|
|
const endIndex = findBlockEnd(lines, startIndex + 1, startBraceCount);
|
|
const innerLines = lines.slice(startIndex + 1, endIndex).map(l => l.trim()).filter(l => l && !l.startsWith('//') && !l.startsWith('/*'));
|
|
// State blocks separate fields with commas or newlines/semicolons.
|
|
// Strip trailing commas (they are field separators, not continuations)
|
|
// then join with semicolons between complete variable declarations.
|
|
const cleanedLines = innerLines.map(l => l.replace(/,+\s*$/, ''));
|
|
const inner = cleanedLines.reduce((acc, line, i) => {
|
|
if (i === 0)
|
|
return line;
|
|
const prevLine = cleanedLines[i - 1];
|
|
// Check if this line starts a new variable declaration (name: type)
|
|
const isNewVar = /^\w+\s*:/.test(line);
|
|
// Check if prev line ends with a continuation character (brace or paren, NOT comma)
|
|
const prevIsContinuation = /[{(]\s*$/.test(prevLine);
|
|
if (isNewVar && !prevIsContinuation) {
|
|
return acc + '; ' + line;
|
|
}
|
|
return acc + ' ' + line;
|
|
}, '');
|
|
const result = parseStateBlock(inner);
|
|
if (messageName !== undefined)
|
|
result.messageName = messageName;
|
|
return result;
|
|
}
|
|
function parseInitBlockMultiline(lines, startIndex, startBraceCount) {
|
|
const endIndex = findBlockEnd(lines, startIndex + 1, startBraceCount);
|
|
const innerLines = lines.slice(startIndex + 1, endIndex).map(l => l.trim()).filter(l => l && !l.startsWith('//') && !l.startsWith('/*'));
|
|
// Init blocks separate fields with commas or newlines/semicolons.
|
|
// Strip trailing commas and join with semicolons.
|
|
const cleanedLines = innerLines.map(l => l.replace(/,+\s*$/, ''));
|
|
const inner = cleanedLines.reduce((acc, line, i) => {
|
|
if (i === 0)
|
|
return line;
|
|
const prevLine = cleanedLines[i - 1];
|
|
const isNewVar = /^\w+\s*:/.test(line);
|
|
const prevIsContinuation = /[{(]\s*$/.test(prevLine);
|
|
if (isNewVar && !prevIsContinuation) {
|
|
return acc + '; ' + line;
|
|
}
|
|
return acc + ' ' + line;
|
|
}, '');
|
|
return parseInitBlock(inner);
|
|
}
|
|
function parseActionBlockMultiline(lines, startIndex, startBraceCount) {
|
|
const firstLine = lines[startIndex].trim();
|
|
const header = parseActionHeader(firstLine);
|
|
if (!header)
|
|
return null;
|
|
const endIndex = findBlockEnd(lines, startIndex + 1, startBraceCount);
|
|
// Keep blank lines as null to separate statements, filter only comments
|
|
const bodyLinesRaw = lines.slice(startIndex + 1, endIndex).map(l => {
|
|
const trimmed = l.trim();
|
|
if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('/*'))
|
|
return null;
|
|
return trimmed;
|
|
});
|
|
// Collapse consecutive nulls and strip trailing nulls
|
|
const bodyLines = [];
|
|
for (const line of bodyLinesRaw) {
|
|
if (line !== null || (bodyLines.length > 0 && bodyLines[bodyLines.length - 1] !== null)) {
|
|
bodyLines.push(line);
|
|
}
|
|
}
|
|
// Remove trailing nulls
|
|
while (bodyLines.length > 0 && bodyLines[bodyLines.length - 1] === null) {
|
|
bodyLines.pop();
|
|
}
|
|
const statements = [];
|
|
for (let i = 0; i < bodyLines.length; i++) {
|
|
const stmtOrNull = bodyLines[i];
|
|
// Skip blank line separators
|
|
if (stmtOrNull === null)
|
|
continue;
|
|
const stmt = stmtOrNull;
|
|
// precondition: expr
|
|
if (stmt.startsWith('precondition:')) {
|
|
let expr = stmt.substring(13).trim();
|
|
// support 'or' continuation lines
|
|
while (i + 1 < bodyLines.length) {
|
|
const nextLine = bodyLines[i + 1];
|
|
if (nextLine === null || !nextLine.startsWith('or '))
|
|
break;
|
|
i++;
|
|
expr += ' || ' + nextLine.substring(3).trim();
|
|
}
|
|
statements.push({ type: 'precondition', expr });
|
|
continue;
|
|
}
|
|
// postcondition: expr
|
|
if (stmt.startsWith('postcondition:')) {
|
|
let expr = stmt.substring(14).trim();
|
|
// support 'or' continuation lines
|
|
while (i + 1 < bodyLines.length) {
|
|
const nextLine = bodyLines[i + 1];
|
|
if (nextLine === null || !nextLine.startsWith('or '))
|
|
break;
|
|
i++;
|
|
expr += ' || ' + nextLine.substring(3).trim();
|
|
}
|
|
statements.push({ type: 'postcondition', expr });
|
|
continue;
|
|
}
|
|
// require expr
|
|
if (stmt.startsWith('require ')) {
|
|
let expr = stmt.substring(8).trim();
|
|
// support multi-line continuation (forall, or, etc.)
|
|
while (i + 1 < bodyLines.length) {
|
|
const nextLine = bodyLines[i + 1];
|
|
if (nextLine === null)
|
|
break;
|
|
// Stop if next line starts a new statement keyword
|
|
if (nextLine.startsWith('precondition:') || nextLine.startsWith('postcondition:') ||
|
|
nextLine.startsWith('require ') || nextLine.startsWith('return ') ||
|
|
nextLine.startsWith('emit ') || nextLine.startsWith('let ') ||
|
|
nextLine.includes(':=')) {
|
|
break;
|
|
}
|
|
i++;
|
|
expr += ' ' + nextLine;
|
|
}
|
|
statements.push({ type: 'require', expr });
|
|
continue;
|
|
}
|
|
// return expr
|
|
if (stmt.startsWith('return ')) {
|
|
statements.push({ type: 'return', expr: stmt.substring(7).trim() });
|
|
continue;
|
|
}
|
|
// emit Event { fields }
|
|
const emitMatch = stmt.match(/^emit\s+(\w+)\s*\{\s*(.*)\s*\}$/);
|
|
if (emitMatch) {
|
|
const eventName = emitMatch[1];
|
|
const fieldsStr = emitMatch[2];
|
|
const fields = [];
|
|
if (fieldsStr) {
|
|
const fieldPairs = splitFields(fieldsStr);
|
|
for (const fp of fieldPairs) {
|
|
const colonIdx = fp.indexOf(':');
|
|
if (colonIdx > 0) {
|
|
fields.push({
|
|
name: fp.substring(0, colonIdx).trim(),
|
|
value: fp.substring(colonIdx + 1).trim(),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
statements.push({ type: 'emit', event: eventName, fields });
|
|
continue;
|
|
}
|
|
// if condition { ... } else if condition { ... } else { ... }
|
|
// SpeckDL conditional blocks - parse as a special statement type
|
|
if (stmt.startsWith('if ')) {
|
|
// Find matching } for this if block (may span multiple bodyLines entries)
|
|
let braceDepth = 0;
|
|
let j = i;
|
|
const blockLines = [];
|
|
while (j < bodyLines.length) {
|
|
const line = bodyLines[j];
|
|
if (line === null) {
|
|
j++;
|
|
continue;
|
|
}
|
|
blockLines.push(line);
|
|
for (const ch of line) {
|
|
if (ch === '{')
|
|
braceDepth++;
|
|
else if (ch === '}')
|
|
braceDepth--;
|
|
}
|
|
j++;
|
|
if (braceDepth === 0)
|
|
break;
|
|
}
|
|
// For now, treat as a raw 'ifblock' statement that the generator can handle
|
|
statements.push({ type: 'ifblock', raw: blockLines.join(' ') });
|
|
i = j - 1; // skip to end of if block
|
|
continue;
|
|
}
|
|
// let name := expr
|
|
const letMatch = stmt.match(/^let\s+(\w+)\s*:=\s*(.+)$/);
|
|
if (letMatch) {
|
|
statements.push({ type: 'let', name: letMatch[1], expr: letMatch[2].trim() });
|
|
continue;
|
|
}
|
|
// assignment: target := expr (may span multiple lines)
|
|
const assignMatch = stmt.match(/^(\w+(?:\[.*?\])?)\s*:=\s*(.+)$/);
|
|
if (assignMatch) {
|
|
let target = assignMatch[1];
|
|
let expr = assignMatch[2].trim();
|
|
// Handle multiline expressions: join subsequent lines until braces/parens are balanced
|
|
while (i + 1 < bodyLines.length && !isExpressionComplete(expr)) {
|
|
i++;
|
|
expr += ' ' + bodyLines[i];
|
|
}
|
|
statements.push({ type: 'assign', target, expr });
|
|
}
|
|
}
|
|
return { ...header, statements };
|
|
}
|
|
function parseEventBlockMultiline(lines, startIndex, startBraceCount) {
|
|
const firstLine = lines[startIndex].trim();
|
|
const header = parseEvent(firstLine);
|
|
const endIndex = findBlockEnd(lines, startIndex + 1, startBraceCount);
|
|
const innerLines = lines.slice(startIndex + 1, endIndex).map(l => l.trim()).filter(l => l && !l.startsWith('//') && !l.startsWith('/*'));
|
|
const fields = [];
|
|
for (const line of innerLines) {
|
|
// Cycle 62: strip inline `//` line-comments from the type expression
|
|
// before parsing. Without this, an event field like
|
|
// mesh_ip: Bytes // 4 bytes (IPv4 overlay)
|
|
// produces a TypeExpr whose name includes the comment text, which
|
|
// the .proto generator emits verbatim:
|
|
// bytes // 4 bytes (IPv4 overlay) mesh_ip = 2;
|
|
// (broken syntax — comment is in the type position).
|
|
const noComment = line.replace(/\/\/.*$/, '').trim();
|
|
// Cycle 65: strip default-value suffix `= <expr>` from the type
|
|
// expression. The federated-meetup speckdl has fields like
|
|
// initial_mesh_peers: List<InitialMeshPeer> = []
|
|
// where the default is meaningful in Speckl semantics (a state-
|
|
// machine init) but the .proto wire format doesn't carry a
|
|
// default — it's a generator concern. Without this, the type
|
|
// expression was emitted as `List<InitialMeshPeer> = []` and
|
|
// protoc rejects the resulting syntax.
|
|
const noDefault = noComment.replace(/\s*=\s*[^,]+$/, '').trim();
|
|
const match = noDefault.match(/^(\w+)\s*:\s*(.+?),?$/);
|
|
if (match) {
|
|
fields.push({ name: match[1], type: parseTypeExpr(match[2].replace(/,$/, '').trim()) });
|
|
}
|
|
}
|
|
return { ...header, fields };
|
|
}
|
|
function parseInterfaceBlockMultiline(lines, startIndex, startBraceCount) {
|
|
const firstLine = lines[startIndex].trim();
|
|
const header = parseInterface(firstLine);
|
|
const endIndex = findBlockEnd(lines, startIndex + 1, startBraceCount);
|
|
const innerLines = lines.slice(startIndex + 1, endIndex).map(l => l.trim()).filter(l => l && !l.startsWith('//') && !l.startsWith('/*'));
|
|
const methods = [];
|
|
const fields = [];
|
|
for (const line of innerLines) {
|
|
// Cycle 62: strip inline `//` line-comments from each line before
|
|
// token-splitting. Without this, a field like
|
|
// mesh_ip: Bytes // 4 bytes (IPv4 overlay)
|
|
// has its comment text bleed into the parsed type expression,
|
|
// which the .proto generator emits verbatim — broken syntax.
|
|
const noComment = line.replace(/\/\/.*$/, '').trim();
|
|
if (!noComment)
|
|
continue;
|
|
// Split on comma so multi-variant lines like "Idle, Parsing, Done" all parse
|
|
const tokens = noComment.split(',').map(s => s.trim()).filter(Boolean);
|
|
for (const token of tokens) {
|
|
// Check 1: method signature form: name(params) -> returnType
|
|
const methodMatch = token.match(/^(\w+)\s*\(([^)]*)\)\s*->\s*(.+?),?$/);
|
|
if (methodMatch) {
|
|
const name = methodMatch[1];
|
|
const paramsStr = methodMatch[2];
|
|
const returnTypeStr = methodMatch[3].replace(/,$/, '').trim();
|
|
const params = [];
|
|
if (paramsStr.trim()) {
|
|
const paramPairs = paramsStr.split(',').map(s => s.trim()).filter(Boolean);
|
|
for (const p of paramPairs) {
|
|
const pMatch = p.match(/^(\w+)\s*:\s*(.+)$/);
|
|
if (pMatch) {
|
|
params.push({ name: pMatch[1], type: parseTypeExpr(pMatch[2].trim()) });
|
|
}
|
|
}
|
|
}
|
|
methods.push({ name, params, returnType: parseTypeExpr(returnTypeStr) });
|
|
continue;
|
|
}
|
|
// Check 2: field declaration form: field_name: TypeName
|
|
// Lowercase-starting identifier followed by ':' — record-style interface
|
|
const fieldMatch = token.match(/^(\w+)\s*:\s*(.+)$/);
|
|
if (fieldMatch && /^[a-z_]/.test(fieldMatch[1])) {
|
|
fields.push({ name: fieldMatch[1], type: parseTypeExpr(fieldMatch[2].trim()) });
|
|
continue;
|
|
}
|
|
// Check 3: bare identifier (enum variant) — name only, no params
|
|
if (/^\w+$/.test(token)) {
|
|
methods.push({ name: token, params: [], returnType: parseTypeExpr('Void') });
|
|
}
|
|
}
|
|
}
|
|
// Determine the kind based on what we collected
|
|
let kind = 'mixed';
|
|
if (fields.length > 0 && methods.length === 0) {
|
|
kind = 'record';
|
|
}
|
|
else if (methods.length > 0 && fields.length === 0) {
|
|
// Distinguish enum (all methods have empty params and Void return) from service
|
|
const allEnumLike = methods.every(m => m.params.length === 0 && m.returnType.name === 'Void');
|
|
kind = allEnumLike ? 'enum' : 'service';
|
|
}
|
|
return { ...header, kind, methods, fields };
|
|
}
|
|
// Cycle 57: parse a `oneof Name { ... }` block. Each non-empty, non-comment
|
|
// inner line is `field_name: TypeName`. The wire field_name follows
|
|
// lowerCamelCase convention (TypeScript/Connect) and is emitted to .proto
|
|
// as snake_case by the generator.
|
|
function parseOneofBlockMultiline(lines, startIndex, startBraceCount) {
|
|
const firstLine = lines[startIndex].trim();
|
|
const header = parseOneof(firstLine);
|
|
const endIndex = findBlockEnd(lines, startIndex + 1, startBraceCount);
|
|
const innerLines = lines.slice(startIndex + 1, endIndex).map(l => l.trim()).filter(l => l && !l.startsWith('//') && !l.startsWith('/*'));
|
|
const variants = [];
|
|
for (const line of innerLines) {
|
|
// Strip trailing comma or semicolon (proto-style "create_group: CreateGroup," is valid).
|
|
const trimmed = line.replace(/[,;]\s*$/, '');
|
|
const m = trimmed.match(/^(\w+)\s*:\s*(\w+)\s*$/);
|
|
if (m) {
|
|
variants.push({ fieldName: m[1], typeName: m[2] });
|
|
}
|
|
}
|
|
return { ...header, variants };
|
|
}
|
|
// Cycle 58: parse a `transition Name { ... }` block. Each non-empty,
|
|
// non-comment inner line is `field_name: TypeName`. Two field names
|
|
// have special meaning:
|
|
// - `payload: <OneofName>` — references a sibling `oneof` block;
|
|
// the proto generator will emit the variants inline as
|
|
// `oneof payload { ... }` inside the message body
|
|
// - `type: <EnumName>` — the discriminator enum for the variants
|
|
// Other fields are emitted as ordinary proto message fields.
|
|
function parseTransitionBlockMultiline(lines, startIndex, startBraceCount) {
|
|
const firstLine = lines[startIndex].trim();
|
|
const header = parseTransition(firstLine);
|
|
const endIndex = findBlockEnd(lines, startIndex + 1, startBraceCount);
|
|
const innerLines = lines.slice(startIndex + 1, endIndex).map(l => l.trim()).filter(l => l && !l.startsWith('//') && !l.startsWith('/*'));
|
|
const fields = [];
|
|
let payloadOneof;
|
|
let typeDiscriminator;
|
|
for (const line of innerLines) {
|
|
const trimmed = line.replace(/[,;]\s*$/, '');
|
|
const m = trimmed.match(/^(\w+)\s*:\s*(.+)$/);
|
|
if (!m)
|
|
continue;
|
|
const fieldName = m[1];
|
|
const typeStr = m[2].trim();
|
|
if (fieldName === 'payload') {
|
|
// The type is the name of a sibling oneof block.
|
|
payloadOneof = typeStr;
|
|
// Don't add a regular field for payload — it becomes the oneof.
|
|
continue;
|
|
}
|
|
if (fieldName === 'type') {
|
|
// The type is the name of a discriminator enum.
|
|
typeDiscriminator = typeStr;
|
|
// Don't add a regular field for type — it's a special discriminator.
|
|
continue;
|
|
}
|
|
fields.push({ name: fieldName, type: parseTypeExpr(typeStr) });
|
|
}
|
|
const result = { ...header, fields };
|
|
if (payloadOneof !== undefined)
|
|
result.payloadOneof = payloadOneof;
|
|
if (typeDiscriminator !== undefined)
|
|
result.typeDiscriminator = typeDiscriminator;
|
|
return result;
|
|
}
|
|
function parseServiceBlockMultiline(lines, startIndex, startBraceCount) {
|
|
// service Name {
|
|
const firstLine = lines[startIndex].trim();
|
|
const match = firstLine.match(/^service\s+(\w+)\s*{?/);
|
|
const name = match ? match[1] : 'UnnamedService';
|
|
const endIndex = findBlockEnd(lines, startIndex + 1, startBraceCount);
|
|
const innerLines = lines.slice(startIndex + 1, endIndex).map(l => l.trim()).filter(l => l && !l.startsWith('//') && !l.startsWith('/*'));
|
|
const rpcs = [];
|
|
for (const line of innerLines) {
|
|
// rpc MethodName(RequestType) returns (ResponseType);
|
|
// Also support streaming: rpc M(stream R) returns (S); or rpc M(R) returns (stream S);
|
|
const rpcMatch = line.match(/^rpc\s+(\w+)\s*\(\s*(stream\s+)?(\w+)\s*\)\s*returns\s*\(\s*(stream\s+)?(\w+)\s*\)\s*;?$/);
|
|
if (rpcMatch) {
|
|
const methodName = rpcMatch[1];
|
|
const clientStream = !!rpcMatch[2];
|
|
const requestType = rpcMatch[3];
|
|
const serverStream = !!rpcMatch[4];
|
|
const responseType = rpcMatch[5];
|
|
rpcs.push({
|
|
name: methodName,
|
|
requestType,
|
|
responseType,
|
|
clientStreaming: clientStream,
|
|
serverStreaming: serverStream,
|
|
});
|
|
}
|
|
}
|
|
return { type: 'service', name, rpcs };
|
|
}
|
|
// --- Multi-line constraint/verify parsing (no braces needed) ---
|
|
/**
|
|
* Parse a constraint or verify that may span multiple lines without braces.
|
|
* Used for forall-style constraints like:
|
|
* constraint Name: forall r in [0..4]:
|
|
* (expr)
|
|
*
|
|
* and verify blocks like:
|
|
* verify Always(Name)
|
|
* verify Always(Name) { depth N }
|
|
*/
|
|
function parseMultiLineConstraintVerify(lines, startIndex) {
|
|
const line = lines[startIndex].trim();
|
|
if (line.startsWith('verify ')) {
|
|
return parseVerifyAnyForm(lines, startIndex);
|
|
}
|
|
// Multi-line `verify:` form: verify: always(implies(\n ...\n))
|
|
// The body opens parens that span multiple lines; collect continuation
|
|
// lines until parens balance to zero, then return the joined string as
|
|
// the temporalExpr. speckl#54.
|
|
if (line.startsWith('verify:')) {
|
|
return parseVerifyColonBlock(lines, startIndex);
|
|
}
|
|
if (line.startsWith('constraint ')) {
|
|
return parseConstraintAnyForm(lines, startIndex);
|
|
}
|
|
return null;
|
|
}
|
|
/**
|
|
* Parse the `verify: <expr>` form (speckl#54) where the body can span
|
|
* multiple lines:
|
|
*
|
|
* verify: always(implies(
|
|
* cond1,
|
|
* cond2
|
|
* ))
|
|
*
|
|
* The whole expression (the part after `verify:`) is collected by
|
|
* appending subsequent non-empty, non-keyword-starting lines until
|
|
* parens/brackets/braces balance to zero. The joined string is stored
|
|
* in `temporalExpr` so the downstream LTL translator (typescript-state-machine
|
|
* verifyN()) sees a well-formed formula.
|
|
*
|
|
* The `name` is derived from the LTL operator's argument when it matches
|
|
* `always(Name)` / `eventually(Name)`. When the body is a richer expression
|
|
* (e.g. `always(implies(...))`) we fall back to `unnamed` — the generator
|
|
* still emits a working verifyN() that uses the full expression.
|
|
*/
|
|
function parseVerifyColonBlock(lines, startIndex) {
|
|
const firstLine = lines[startIndex].trim();
|
|
// Strip the `verify:` prefix.
|
|
const head = firstLine.substring(firstLine.indexOf(':') + 1).trim();
|
|
if (!head)
|
|
return null;
|
|
// If the head is already balanced on its own (single-line verify: expr),
|
|
// just return it directly — no continuation needed.
|
|
if (isExpressionComplete(head)) {
|
|
const nameMatch = head.match(/^(?:always|Always|eventually|Eventually)\s*\(\s*(\w+)\s*\)$/);
|
|
return {
|
|
type: 'verify',
|
|
name: nameMatch ? nameMatch[1] : 'unnamed',
|
|
temporalExpr: head,
|
|
};
|
|
}
|
|
// Multi-line: collect continuation lines until parens balance. The same
|
|
// break-condition list used in the parseSpeck skip-loop applies (don't
|
|
// swallow the next member's keyword). We additionally stop at any
|
|
// standalone `}` so a verify inside a brace-block still terminates.
|
|
const parts = [head];
|
|
let parens = 0, brackets = 0, braces = 0;
|
|
for (const ch of head) {
|
|
if (ch === '(')
|
|
parens++;
|
|
else if (ch === ')')
|
|
parens--;
|
|
else if (ch === '[')
|
|
brackets++;
|
|
else if (ch === ']')
|
|
brackets--;
|
|
else if (ch === '{')
|
|
braces++;
|
|
else if (ch === '}')
|
|
braces--;
|
|
}
|
|
let lastConsumed = startIndex;
|
|
for (let j = startIndex + 1; j < lines.length; j++) {
|
|
const raw = lines[j];
|
|
const nl = raw.trim();
|
|
if (!nl) {
|
|
// Empty line still updates counters (none) and advances lastConsumed
|
|
lastConsumed = j;
|
|
continue;
|
|
}
|
|
if (nl.startsWith('//') || nl.startsWith('/*')) {
|
|
// Skip standalone comments but treat them as part of the block
|
|
// (the LTL translator doesn't care about comments in temporalExpr).
|
|
lastConsumed = j;
|
|
continue;
|
|
}
|
|
// Stop at a new top-level member keyword — that's the next member.
|
|
if (nl.startsWith('constraint ') || nl.startsWith('verify ') ||
|
|
nl.startsWith('constraint:') || nl.startsWith('verify:') ||
|
|
nl.startsWith('state') || nl.startsWith('init') ||
|
|
nl.startsWith('action ') || nl.startsWith('event ') ||
|
|
nl.startsWith('interface ') || nl.startsWith('provenance ') ||
|
|
nl.startsWith('bom ') || nl === '}' ||
|
|
nl.startsWith('next:') || nl.startsWith('invariant ')) {
|
|
break;
|
|
}
|
|
// Update depth counters.
|
|
for (const ch of raw) {
|
|
if (ch === '(')
|
|
parens++;
|
|
else if (ch === ')')
|
|
parens--;
|
|
else if (ch === '[')
|
|
brackets++;
|
|
else if (ch === ']')
|
|
brackets--;
|
|
else if (ch === '{')
|
|
braces++;
|
|
else if (ch === '}')
|
|
braces--;
|
|
}
|
|
parts.push(nl);
|
|
lastConsumed = j;
|
|
if (parens === 0 && brackets === 0 && braces === 0) {
|
|
break;
|
|
}
|
|
}
|
|
const joined = parts.join(' ').replace(/\s+/g, ' ').trim();
|
|
const nameMatch = joined.match(/^(?:always|Always|eventually|Eventually)\s*\(\s*(\w+)\s*\)$/);
|
|
return {
|
|
type: 'verify',
|
|
name: nameMatch ? nameMatch[1] : 'unnamed',
|
|
temporalExpr: joined,
|
|
};
|
|
}
|
|
function parseConstraintAnyForm(lines, startIndex) {
|
|
const line = lines[startIndex].trim();
|
|
const namedMatch = line.match(/^constraint\s+(\w+):(.*)$/);
|
|
if (!namedMatch)
|
|
return null;
|
|
const name = namedMatch[1];
|
|
let expr = namedMatch[2].trim();
|
|
// If opens a brace, treat as block
|
|
if (expr.startsWith('{')) {
|
|
const afterBrace = expr.substring(1).trim();
|
|
const openCount = (line.match(/{/g) || []).length;
|
|
const endIdx = findBlockEnd(lines, startIndex + 1, openCount);
|
|
const innerLines = lines.slice(startIndex + 1, endIdx).map(l => l.trim()).filter(l => l && !l.startsWith('//') && !l.startsWith('/*'));
|
|
const inner = innerLines.join(' ');
|
|
expr = (afterBrace + ' ' + inner).trim();
|
|
}
|
|
else {
|
|
// No braces — but might span multiple lines (forall continuation)
|
|
const continuationLines = [];
|
|
for (let j = startIndex + 1; j < lines.length; j++) {
|
|
const nl = lines[j].trim();
|
|
if (!nl || nl.startsWith('//') || nl.startsWith('/*') ||
|
|
nl.startsWith('constraint ') || nl.startsWith('verify ') ||
|
|
nl.startsWith('constraint:') || nl.startsWith('verify:') ||
|
|
nl.startsWith('state') || nl.startsWith('init') ||
|
|
nl.startsWith('action ') || nl.startsWith('event ') ||
|
|
nl.startsWith('interface ') || nl.startsWith('provenance ') ||
|
|
nl.startsWith('bom ') || nl.startsWith('}') ||
|
|
nl.startsWith('next:') || nl.startsWith('invariant ')) {
|
|
break;
|
|
}
|
|
continuationLines.push(nl);
|
|
}
|
|
if (continuationLines.length > 0) {
|
|
expr = expr + ' ' + continuationLines.join(' ');
|
|
}
|
|
}
|
|
return { type: 'constraint', name, expr: expr.trim() };
|
|
}
|
|
function parseVerifyAnyForm(lines, startIndex) {
|
|
const line = lines[startIndex].trim();
|
|
// Single-line: verify Always(Name) { depth N }
|
|
const fullMatch = line.match(/^verify\s+((?:Always|always|Eventually|eventually)\s*\(\s*(\w+)\s*\))\s*\{\s*depth\s+(\d+)\s*\}/);
|
|
if (fullMatch) {
|
|
return {
|
|
type: 'verify',
|
|
name: fullMatch[2],
|
|
temporalExpr: fullMatch[1].trim(),
|
|
depth: parseInt(fullMatch[3], 10),
|
|
};
|
|
}
|
|
// Multi-line: verify Always(Name) { ... }
|
|
if (line.includes('{')) {
|
|
const headerMatch = line.match(/^verify\s+((?:Always|always|Eventually|eventually)\s*\(\s*(\w+)\s*\))\s*\{/);
|
|
if (headerMatch) {
|
|
const temporalExpr = headerMatch[1].trim();
|
|
const name = headerMatch[2];
|
|
const openCount = (line.match(/{/g) || []).length;
|
|
const endIdx = findBlockEnd(lines, startIndex + 1, openCount);
|
|
const innerLines = lines.slice(startIndex + 1, endIdx).map(l => l.trim()).filter(l => l && !l.startsWith('//') && !l.startsWith('/*'));
|
|
const inner = innerLines.join(' ');
|
|
const afterBrace = line.substring(line.indexOf('{') + 1).trim();
|
|
const combined = (afterBrace + ' ' + inner).trim();
|
|
const depthMatch = combined.match(/\bdepth\s+(\d+)\b/);
|
|
const depth = depthMatch ? parseInt(depthMatch[1], 10) : undefined;
|
|
return { type: 'verify', name, temporalExpr, depth };
|
|
}
|
|
}
|
|
// Simple: verify Always(Name)
|
|
const simpleMatch = line.match(/^verify\s+((?:Always|always|Eventually|eventually)\s*\(\s*(\w+)\s*\))\s*$/);
|
|
if (simpleMatch) {
|
|
return {
|
|
type: 'verify',
|
|
name: simpleMatch[2],
|
|
temporalExpr: simpleMatch[1].trim(),
|
|
};
|
|
}
|
|
return null;
|
|
}
|
|
// --- Verify/Constraint block parsing ---
|
|
/**
|
|
* Parse a verify block opened with `verify Always(Name) { ... }` or similar.
|
|
* The first line already contains the header; we need to parse the body inside { }.
|
|
*/
|
|
function parseVerifyBlockMultiline(lines, startIndex, startBraceCount) {
|
|
const firstLine = lines[startIndex].trim();
|
|
// Match: verify Always(Name) { depth N } or verify Always(Name) {
|
|
const headerMatch = firstLine.match(/^verify\s+((?:Always|always|Eventually|eventually)\s*\(\s*(\w+)\s*\))\s*\{/);
|
|
if (!headerMatch)
|
|
return null;
|
|
const temporalExpr = headerMatch[1].trim();
|
|
const name = headerMatch[2];
|
|
// Check if the brace closes on the same line (single-line form)
|
|
const openBraceCount = (firstLine.match(/{/g) || []).length;
|
|
const closeBraceCount = (firstLine.match(/}/g) || []).length;
|
|
if (closeBraceCount >= openBraceCount) {
|
|
// Single-line: parse depth from same line
|
|
const afterBrace = firstLine.substring(firstLine.indexOf('{') + 1);
|
|
const beforeClose = afterBrace.substring(0, afterBrace.lastIndexOf('}')).trim();
|
|
const depthMatch = beforeClose.match(/\bdepth\s+(\d+)\b/);
|
|
const depth = depthMatch ? parseInt(depthMatch[1], 10) : undefined;
|
|
return { type: 'verify', name, temporalExpr, depth };
|
|
}
|
|
// Multi-line block
|
|
let depth;
|
|
const endIdx = findBlockEnd(lines, startIndex + 1, startBraceCount);
|
|
const innerLines = lines.slice(startIndex + 1, endIdx).map(l => l.trim()).filter(l => l && !l.startsWith('//') && !l.startsWith('/*'));
|
|
const inner = innerLines.join(' ');
|
|
const afterBrace = firstLine.substring(firstLine.indexOf('{') + 1).trim();
|
|
const depthMatch = (afterBrace + ' ' + inner).match(/\bdepth\s+(\d+)\b/);
|
|
if (depthMatch) {
|
|
depth = parseInt(depthMatch[1], 10);
|
|
}
|
|
return { type: 'verify', name, temporalExpr, depth };
|
|
}
|
|
/**
|
|
* Parse a single-line verify statement: verify Always(Name) { depth N }
|
|
*/
|
|
function parseVerifySingleLine(line) {
|
|
// verify Always(Name) { depth N }
|
|
const fullMatch = line.match(/^verify\s+((?:Always|always|Eventually|eventually)\s*\(\s*(\w+)\s*\))\s*\{\s*depth\s+(\d+)\s*\}/);
|
|
if (fullMatch) {
|
|
return {
|
|
type: 'verify',
|
|
name: fullMatch[2],
|
|
temporalExpr: fullMatch[1].trim(),
|
|
depth: parseInt(fullMatch[3], 10),
|
|
};
|
|
}
|
|
// verify Always(Name) (no depth, no braces — just a statement)
|
|
const simpleMatch = line.match(/^verify\s+((?:Always|always|Eventually|eventually)\s*\(\s*(\w+)\s*\))\s*$/);
|
|
if (simpleMatch) {
|
|
return {
|
|
type: 'verify',
|
|
name: simpleMatch[2],
|
|
temporalExpr: simpleMatch[1].trim(),
|
|
};
|
|
}
|
|
return null;
|
|
}
|
|
/**
|
|
* Parse a constraint block opened with `constraint Name: ...` which may
|
|
* be multi-line (e.g. forall spanning multiple lines).
|
|
*/
|
|
function parseConstraintBlockMultiline(lines, startIndex, startBraceCount) {
|
|
const firstLine = lines[startIndex].trim();
|
|
// Match: constraint Name: expr (possibly opening a {} block, or just a forall on next line)
|
|
// For the SQLiteWAL style: constraint Name: expr (single line, no braces needed)
|
|
const namedMatch = firstLine.match(/^constraint\s+(\w+):(.*)$/);
|
|
if (namedMatch) {
|
|
const name = namedMatch[1];
|
|
let expr = namedMatch[2].trim();
|
|
// If the expression opens a brace, collect the block
|
|
if (expr.startsWith('{')) {
|
|
const endIdx = findBlockEnd(lines, startIndex + 1, startBraceCount);
|
|
const innerLines = lines.slice(startIndex + 1, endIdx).map(l => l.trim()).filter(l => l && !l.startsWith('//') && !l.startsWith('/*'));
|
|
const inner = innerLines.join(' ');
|
|
// Combine: content after { on first line + content from inner lines
|
|
const afterBrace = expr.substring(1).trim();
|
|
expr = (afterBrace + ' ' + inner).trim();
|
|
}
|
|
else {
|
|
// No braces, but might still be multiline (forall spanning multiple lines)
|
|
// Check if next line(s) continue the expression
|
|
const endIdx = findBlockEnd(lines, startIndex + 1, startBraceCount);
|
|
const innerLines = lines.slice(startIndex + 1, endIdx).map(l => l.trim()).filter(l => l && !l.startsWith('//') && !l.startsWith('/*'));
|
|
if (innerLines.length > 0) {
|
|
expr = expr + ' ' + innerLines.join(' ');
|
|
}
|
|
}
|
|
return { type: 'constraint', name, expr: expr.trim() };
|
|
}
|
|
return null;
|
|
}
|
|
/** Split on commas while respecting parenthesized groups and quoted strings */
|
|
function splitFields(s) {
|
|
const result = [];
|
|
let depth = 0;
|
|
let inDouble = false;
|
|
let inSingle = false;
|
|
let start = 0;
|
|
for (let i = 0; i < s.length; i++) {
|
|
const ch = s[i];
|
|
if (ch === '"' && !inSingle) {
|
|
inDouble = !inDouble;
|
|
continue;
|
|
}
|
|
if (ch === "'" && !inDouble) {
|
|
inSingle = !inSingle;
|
|
continue;
|
|
}
|
|
if (inDouble || inSingle)
|
|
continue;
|
|
if (ch === '(' || ch === '{') {
|
|
depth++;
|
|
continue;
|
|
}
|
|
if (ch === ')' || ch === '}') {
|
|
depth--;
|
|
continue;
|
|
}
|
|
if (ch === ',' && depth === 0) {
|
|
result.push(s.substring(start, i).trim());
|
|
start = i + 1;
|
|
}
|
|
}
|
|
const last = s.substring(start).trim();
|
|
if (last)
|
|
result.push(last);
|
|
return result;
|
|
}
|
|
//# sourceMappingURL=parser.js.map
|