stackLifecycle025ParityProbe method
Direct managed-GSS transcript for the small Tree-sitter 0.25.10 stack accessors and version lifecycle transitions.
Implementation
Map<String, Object?> stackLifecycle025ParityProbe() {
const origin = TreeSitterTablePoint(0, 0);
const atOne = TreeSitterTablePoint(0, 1);
const atThree = TreeSitterTablePoint(0, 3);
GeneratedTreeSitterNode leaf({
required int startByte,
required int endByte,
int dynamicPrecedence = 0,
}) => GeneratedTreeSitterNode(
symbol: 1,
type: language.symbols[1].name,
startByte: startByte,
endByte: endByte,
startPoint: TreeSitterTablePoint(0, startByte),
endPoint: TreeSitterTablePoint(0, endByte),
named: language.symbols[1].named,
visible: true,
extra: false,
dynamicPrecedence: dynamicPrecedence,
);
final unexpected = GeneratedTreeSitterNode(
symbol: _treeSitterBuiltinErrorSymbol,
type: 'ERROR',
startByte: 0,
endByte: 1,
startPoint: origin,
endPoint: atOne,
named: true,
visible: true,
extra: false,
unexpectedCharacter: 33,
);
final error = GeneratedTreeSitterNode(
symbol: _treeSitterBuiltinErrorSymbol,
type: 'ERROR',
startByte: 0,
endByte: 1,
startPoint: origin,
endPoint: atOne,
named: true,
visible: true,
extra: false,
children: [unexpected],
);
final graph = _GssContext(nodeErrorCost: _stackNodeErrorCost);
_ParseStack initialStack(int partition) {
final stack = _ParseStack(
frames: _FrameStack.of([_Frame(1, null, extra: false)]),
position: 0,
point: origin,
dynamicPrecedence: 0,
errorCost: 0,
recoverySteps: 0,
recovering: false,
zeroWidthExternalTokens: <String>{},
scannerState: Uint8List(0),
gssPartition: partition,
);
stack.arenaHead = graph.initialize(stack);
return stack;
}
final value = initialStack(1);
final slots = <_VersionSlot>[_VersionSlot(id: 0, stack: value)];
void push(_ParseStack stack, _Frame frame) {
final head = graph.push(
predecessorHead: stack.arenaHead!,
frame: frame,
stack: stack,
)!;
stack
..frames.add(frame)
..arenaHead = head
..position = graph.arena.positionOf(head)
..point = graph.arena.payloadOf(head).point
..errorCost = graph.arena.payloadOf(head).errorCost
..dynamicPrecedence = graph.arena.payloadOf(head).dynamicPrecedence;
}
final previousGraph = _activeGss;
_activeGss = graph;
try {
final result = <String, Object?>{
'initial_version_count': slots.length,
'base_state': value.frames.last.state,
'base_position': value.position,
};
push(value, _Frame(0, error, extra: false));
push(value, _Frame(0, null, extra: false));
value
..recovering = true
..nodeCountAtLastError = _currentStackNodeCount(value);
result.addAll(<String, Object?>{
'error_state': value.frames.last.state,
'error_position': value.position,
'error_node_count_since_error': _nodeCountSinceError(value),
'error_has_advanced': _hasAdvancedSinceError(value),
});
push(value, _Frame(2, leaf(startByte: 1, endByte: 1), extra: false));
result.addAll(<String, Object?>{
'zero_state': value.frames.last.state,
'zero_position': value.position,
'zero_node_count_since_error': _nodeCountSinceError(value),
'zero_has_advanced': _hasAdvancedSinceError(value),
});
push(value, _Frame(3, leaf(startByte: 1, endByte: 3), extra: false));
result.addAll(<String, Object?>{
'width_state': value.frames.last.state,
'width_position': value.position,
'width_node_count_since_error': _nodeCountSinceError(value),
'width_has_advanced': _hasAdvancedSinceError(value),
});
final lookahead = _TokenCandidate(
const TreeSitterTableToken(
symbol: 0,
text: '',
startByte: 3,
endByte: 6,
startPoint: atThree,
endPoint: TreeSitterTablePoint(0, 6),
),
Uint8List(0),
);
final paused = _pauseForRecovery(value, lookahead);
slots.add(_VersionSlot(id: 1, stack: paused));
result.addAll(<String, Object?>{
'pause_version_count': slots.length,
'pause_state': paused.frames.last.state,
'pause_position': paused.position,
'pause_marker': paused.nodeCountAtLastError,
'pause_status': paused.status == _ParseStackStatus.paused,
'pause_lookahead_symbol': paused.pausedLookahead?.token.symbol,
});
final resumedLookahead = _resumePausedVersion(paused);
result.addAll(<String, Object?>{
'resume_active': paused.status == _ParseStackStatus.active,
'resume_lookahead_symbol': resumedLookahead?.token.symbol,
'resume_cleared': paused.pausedLookahead == null,
'resume_marker': paused.nodeCountAtLastError,
});
final halted = value.copy();
slots.add(_VersionSlot(id: 2, stack: halted));
final haltCountBefore = slots.length;
final haltStateBefore = halted.frames.last.state;
final haltPositionBefore = halted.position;
halted.status = _ParseStackStatus.halted;
slots.last.status = _ParseStackStatus.halted;
result.addAll(<String, Object?>{
'halt_count_before': haltCountBefore,
'halt_count_after': slots.length,
'halt_status': halted.status == _ParseStackStatus.halted,
'halt_state_preserved': halted.frames.last.state == haltStateBefore,
'halt_position_preserved': halted.position == haltPositionBefore,
});
final clamped = value.copy()
..gssPartition = 2
..nodeCountAtLastError = _currentStackNodeCount(value) + 5;
slots.add(_VersionSlot(id: 3, stack: clamped));
final clampedCount = _nodeCountSinceError(clamped);
final clampedMarker = clamped.nodeCountAtLastError;
push(clamped, _Frame(2, leaf(startByte: 3, endByte: 3), extra: false));
result.addAll(<String, Object?>{
'clamped_count': clampedCount,
'clamped_marker': clampedMarker,
'after_clamp_count': _nodeCountSinceError(clamped),
'final_version_count': slots.length,
});
final mergeBase = initialStack(10);
push(mergeBase, _Frame(2, leaf(startByte: 0, endByte: 1), extra: false));
mergeBase.scannerState = Uint8List.fromList(const [3, 4, 5]);
final mergeEqual = mergeBase.copyVersion();
final canMergeEqual = _canMergeRecoveryStacks(mergeBase, mergeEqual);
final mergeScannerMismatch = mergeBase.copyVersion()
..scannerState = Uint8List.fromList(const [1, 2]);
final canMergeScannerMismatch = _canMergeRecoveryStacks(
mergeBase,
mergeScannerMismatch,
);
final mergePaused = mergeBase.copyVersion()
..status = _ParseStackStatus.paused;
final canMergePaused = _canMergeRecoveryStacks(mergeBase, mergePaused);
final mergeState = mergeBase.copyVersion();
push(mergeState, _Frame(3, null, extra: false));
final canMergeState = _canMergeRecoveryStacks(mergeBase, mergeState);
final mergePosition = mergeBase.copyVersion();
push(
mergePosition,
_Frame(2, leaf(startByte: 1, endByte: 2), extra: false),
);
final canMergePosition = _canMergeRecoveryStacks(
mergeBase,
mergePosition,
);
final mergeError = mergeBase.copyVersion();
final mergePayload = graph.arena.payloadOf(mergeBase.arenaHead!);
final mergeErrorHead = graph.arena.createHead(
partition: mergeError.gssPartition,
state: mergeError.frames.last.state,
position: mergeError.position,
payload: _GssHeadPayload.fromStack(
mergeError,
point: mergePayload.point,
scannerState: mergePayload.scannerState,
nodeCount: mergePayload.nodeCount,
dynamicPrecedence: mergePayload.dynamicPrecedence,
errorCost: mergePayload.errorCost + 1,
),
);
graph.rememberRepresentative(mergeErrorHead, mergeError.frames);
mergeError.arenaHead = mergeErrorHead;
final canMergeError = _canMergeRecoveryStacks(mergeBase, mergeError);
final versionBase = initialStack(20);
push(versionBase, _Frame(10, null, extra: false));
versionBase
..scannerState = Uint8List.fromList(const [1, 2])
..summary = const [
_StackSummaryEntry(state: 10, position: 0, point: origin, depth: 0),
];
final versionSlots = <_VersionSlot>[
_VersionSlot(id: 0, stack: versionBase),
];
final versionOne = versionBase.copyVersion();
final copySharedHead = versionOne.arenaHead == versionBase.arenaHead;
final copySummaryCleared = versionOne.summary.isEmpty;
push(versionOne, _Frame(11, null, extra: false));
versionSlots.add(_VersionSlot(id: 1, stack: versionOne));
final versionTwo = versionBase.copyVersion();
final copyScannerEqual = _sameBytes(
versionTwo.scannerState,
Uint8List.fromList(const [1, 2]),
);
push(versionTwo, _Frame(12, null, extra: false));
versionSlots.add(_VersionSlot(id: 2, stack: versionTwo));
final copyVersionCount = versionSlots.length;
versionBase.scannerState = Uint8List.fromList(const [3, 4, 5]);
final setOriginalScanner = _sameBytes(
versionBase.scannerState,
Uint8List.fromList(const [3, 4, 5]),
);
final copyScannerIsolated = _sameBytes(
versionTwo.scannerState,
Uint8List.fromList(const [1, 2]),
);
final swapped = versionSlots[0];
versionSlots[0] = versionSlots[2];
versionSlots[2] = swapped;
final swapStates = [
versionSlots[0].stack.frames.last.state,
versionSlots[2].stack.frames.last.state,
];
versionSlots.removeAt(1);
final removeStates = [
versionSlots[0].stack.frames.last.state,
versionSlots[1].stack.frames.last.state,
];
final renumberTarget = initialStack(30)
..summary = const [
_StackSummaryEntry(state: 10, position: 0, point: origin, depth: 0),
];
push(renumberTarget, _Frame(10, null, extra: false));
final renumberSource = renumberTarget.copyVersion();
push(renumberSource, _Frame(11, null, extra: false));
final renumberSlots = <_VersionSlot>[
_VersionSlot(id: 0, stack: renumberTarget),
_VersionSlot(id: 1, stack: renumberSource),
];
final renumberSourceSummaryBefore = renumberSource.summary.isNotEmpty;
renumberSlots[0].replace(
renumberSlots[1].stack,
withStatus: _ParseStackStatus.active,
);
renumberSlots.removeAt(1);
final clearBase = initialStack(40);
push(clearBase, _Frame(2, leaf(startByte: 0, endByte: 2), extra: false));
final clearCopy = clearBase.copyVersion()
..status = _ParseStackStatus.paused;
final clearSlots = <_VersionSlot>[
_VersionSlot(id: 0, stack: clearBase),
_VersionSlot(id: 1, stack: clearCopy),
];
clearBase.scannerState = Uint8List.fromList(const [9]);
final cleared = _ParseStack(
frames: _FrameStack.of([_Frame(1, null, extra: false)]),
position: 0,
point: origin,
dynamicPrecedence: 0,
errorCost: 0,
recoverySteps: 0,
recovering: false,
zeroWidthExternalTokens: <String>{},
scannerState: Uint8List(0),
);
final clearedHead = graph.arena.resetToBase(
payload: _GssHeadPayload.fromStack(cleared, nodeCount: 0),
);
cleared.arenaHead = clearedHead;
clearSlots
..clear()
..add(_VersionSlot(id: 0, stack: cleared));
final clearSingleBase =
clearSlots.length == 1 &&
graph.arena.nodeCount == 1 &&
graph.arena.linkCount == 0 &&
graph.arena.stateOf(clearedHead) == 1 &&
graph.arena.positionOf(clearedHead) == 0 &&
cleared.status == _ParseStackStatus.active;
final versionOperations = <String, Object?>{
'can_merge_equal': canMergeEqual,
'can_merge_scanner_mismatch': canMergeScannerMismatch,
'can_merge_paused': canMergePaused,
'can_merge_state_mismatch': canMergeState,
'can_merge_position_mismatch': canMergePosition,
'can_merge_error_mismatch': canMergeError,
'copy_shared_head': copySharedHead,
'copy_summary_cleared': copySummaryCleared,
'copy_scanner_equal': copyScannerEqual,
'copy_version_count': copyVersionCount,
'set_original_scanner': setOriginalScanner,
'copy_scanner_isolated': copyScannerIsolated,
'swap_states': swapStates,
'remove_count': versionSlots.length,
'remove_states': removeStates,
'renumber_source_summary_before': renumberSourceSummaryBefore,
'renumber_summary_transferred':
renumberSlots.single.stack.summary.isNotEmpty,
'renumber_count': renumberSlots.length,
'renumber_state': renumberSlots.single.stack.frames.last.state,
'clear_single_base': clearSingleBase,
'clear_scanner_empty': cleared.scannerState.isEmpty,
};
final remainingGraph = _GssContext(nodeErrorCost: _stackNodeErrorCost);
_ParseStack remainingStack(int partition) {
final stack = _ParseStack(
frames: _FrameStack.of([_Frame(1, null, extra: false)]),
position: 0,
point: origin,
dynamicPrecedence: 0,
errorCost: 0,
recoverySteps: 0,
recovering: false,
zeroWidthExternalTokens: <String>{},
scannerState: Uint8List(0),
gssPartition: partition,
);
stack.arenaHead = remainingGraph.initialize(stack);
return stack;
}
void remainingPush(_ParseStack stack, _Frame frame) {
final head = remainingGraph.push(
predecessorHead: stack.arenaHead!,
frame: frame,
stack: stack,
)!;
stack
..frames.add(frame)
..arenaHead = head
..position = remainingGraph.arena.positionOf(head)
..point = remainingGraph.arena.payloadOf(head).point
..errorCost = remainingGraph.arena.payloadOf(head).errorCost
..dynamicPrecedence = remainingGraph.arena
.payloadOf(head)
.dynamicPrecedence;
}
final iteratorLeft = remainingStack(50);
final iteratorRoot = iteratorLeft.arenaHead!;
final iteratorRight = iteratorLeft.copyVersion()..gssPartition = 51;
remainingPush(
iteratorLeft,
_Frame(2, leaf(startByte: 0, endByte: 1), extra: false),
);
final iteratorNewNode = iteratorLeft.arenaHead!;
remainingPush(
iteratorRight,
_Frame(3, leaf(startByte: 0, endByte: 1), extra: false),
);
remainingPush(
iteratorLeft,
_Frame(
4,
leaf(startByte: 1, endByte: 3, dynamicPrecedence: 3),
extra: false,
),
);
remainingPush(
iteratorRight,
_Frame(
4,
leaf(startByte: 1, endByte: 3, dynamicPrecedence: 3),
extra: false,
),
);
final iteratorTop = iteratorLeft.arenaHead!;
remainingGraph.mergeHeadInto(
target: iteratorTop,
source: iteratorRight.arenaHead!,
);
final addLinkBranchCount = remainingGraph.arena.linkCountOf(iteratorTop);
final duplicate = remainingGraph.arena.link(
remainingGraph.arena.linkIdAt(iteratorTop, 0),
);
remainingGraph.arena.addLink(
head: iteratorTop,
predecessor: duplicate.predecessor,
structural: duplicate.structural,
payload: duplicate.payload,
);
final addLinkDuplicateCount = remainingGraph.arena.linkCountOf(
iteratorTop,
);
remainingGraph.arena.addLink(
head: iteratorTop,
predecessor: iteratorTop,
structural: true,
payload: _Frame(4, null, extra: false),
);
final addLinkSelfCount = remainingGraph.arena.linkCountOf(iteratorTop);
remainingGraph.arena.addLink(
head: iteratorTop,
predecessor: duplicate.predecessor,
structural: true,
payload: _Frame(
4,
leaf(startByte: 1, endByte: 3, dynamicPrecedence: 7),
extra: false,
),
);
final addLinkReplacedPrecedence = remainingGraph.arena
.payloadOf(iteratorTop)
.dynamicPrecedence;
final remainingSummary = remainingGraph.summarize(
iteratorTop,
maxDepth: 4,
);
iteratorLeft.summary = remainingSummary;
final getSummarySameInstance = identical(
iteratorLeft.summary,
remainingSummary,
);
final iteratorPop = remainingGraph.arena.popStructural(iteratorTop, 2);
final iteratorPredecessors = <int>{
for (final path in iteratorPop.paths) path.predecessor,
};
final iteratorFirstSubtreeCount = iteratorPop.paths.isEmpty
? 0
: iteratorPop.paths.first.linkIds.length;
final iteratorSecondSubtreeCount = iteratorPop.paths.length < 2
? 0
: iteratorPop.paths[1].linkIds.length;
final remainingPopAll = remainingGraph.materialize(iteratorTop);
for (var bytes = 3; bytes <= 8; bytes++) {
remainingGraph.arena.addLink(
head: iteratorTop,
predecessor: duplicate.predecessor,
structural: true,
payload: _Frame(4, leaf(startByte: 0, endByte: bytes), extra: false),
);
}
final addLinkCapCount = remainingGraph.arena.linkCountOf(iteratorTop);
final ninthLink = remainingGraph.arena.addLink(
head: iteratorTop,
predecessor: duplicate.predecessor,
structural: true,
payload: _Frame(4, leaf(startByte: 0, endByte: 9), extra: false),
);
final pendingStack = remainingStack(60);
remainingPush(
pendingStack,
_Frame(2, leaf(startByte: 0, endByte: 1), extra: false, pending: true),
);
final pendingPop = remainingGraph.popPending(pendingStack.arenaHead!);
final nonpendingStack = remainingStack(61);
remainingPush(
nonpendingStack,
_Frame(2, leaf(startByte: 0, endByte: 1), extra: false),
);
final nonpendingPop = remainingGraph.popPending(
nonpendingStack.arenaHead!,
);
final errorStack = remainingStack(70);
remainingPush(errorStack, _Frame(0, error, extra: false));
final remainingPopError = remainingGraph.popError(errorStack.arenaHead!);
final nonerrorPop = remainingGraph.popError(nonpendingStack.arenaHead!);
final dotStack = iteratorLeft.copyVersion()..gssPartition = 80;
remainingPush(
dotStack,
_Frame(5, leaf(startByte: 3, endByte: 4), extra: false, pending: true),
);
final dot = remainingGraph.arena.toDotGraph(
heads: <int>[dotStack.arenaHead!, iteratorTop, iteratorTop],
pausedVersions: const <int>{1},
haltedVersions: const <int>{2},
linkIsPending: (frame) => frame.pending,
);
final ownershipGraph = _GssContext(nodeErrorCost: _stackNodeErrorCost);
final ownershipStack = _ParseStack(
frames: _FrameStack.of([_Frame(1, null, extra: false)]),
position: 0,
point: origin,
dynamicPrecedence: 0,
errorCost: 0,
recoverySteps: 0,
recovering: false,
zeroWidthExternalTokens: <String>{},
scannerState: Uint8List(0),
);
ownershipStack.arenaHead = ownershipGraph.initialize(ownershipStack);
final ownedNode = ownershipGraph.arena.createHead(
state: 2,
position: 1,
payload: _GssHeadPayload.fromStack(ownershipStack, nodeCount: 1),
);
final alias = ownershipGraph.arena.retainManagedNode(ownedNode);
ownershipGraph.arena.releaseManagedNode(alias);
ownershipGraph.arena.releaseManagedHead(ownedNode);
final headDeleteSharedSurvives =
ownershipGraph.arena.stateOf(ownedNode) == 2;
ownershipGraph.arena.dispose();
ownershipGraph.arena.dispose();
final remainingOperations = <String, Object?>{
'node_new_state': remainingGraph.arena.stateOf(iteratorNewNode),
'node_new_position': remainingGraph.arena.positionOf(iteratorNewNode),
'node_new_link_count': remainingGraph.arena.linkCountOf(
iteratorNewNode,
),
'node_new_node_count': remainingGraph.arena
.payloadOf(iteratorNewNode)
.nodeCount,
'node_new_exclusive_owner': true,
'add_link_merged': true,
'add_link_branch_count': addLinkBranchCount,
'add_link_duplicate_count': addLinkDuplicateCount,
'add_link_self_count': addLinkSelfCount,
'add_link_replaced_precedence': addLinkReplacedPrecedence,
'add_link_cap_count': addLinkCapCount,
'add_link_ninth_dropped': ninthLink == null,
'get_summary_same_instance': getSummarySameInstance,
'get_summary_entries': <String>[
for (final entry in remainingSummary)
'${entry.state}:${entry.position}:${entry.depth}',
],
'iter_slice_count': iteratorPop.paths.length,
'iter_slice_versions_same': iteratorPredecessors.length == 1,
'add_version_count': iteratorPredecessors.length,
'add_slice_first_subtree_count': iteratorFirstSubtreeCount,
'add_slice_second_subtree_count': iteratorSecondSubtreeCount,
'add_slice_state': remainingGraph.arena.stateOf(iteratorRoot),
'pop_all_size': remainingPopAll.length,
'pop_all_versions_same': remainingPopAll.length == 2,
'pop_pending_size': pendingPop.length,
'pop_pending_state': pendingPop.isEmpty
? 0
: remainingGraph.arena.stateOf(pendingPop.first.predecessor),
'pop_pending_subtrees': pendingPop.isEmpty
? 0
: pendingPop.first.frames.length,
'pop_nonpending_size': nonpendingPop.length,
'pop_error_size': remainingPopError == null ? 0 : 1,
'pop_error_state': remainingPopError == null
? 0
: remainingGraph.arena.stateOf(remainingPopError.predecessor),
'pop_nonerror_size': nonerrorPop == null ? 0 : 1,
'retain_adds_ownership': alias == ownedNode,
'release_balances_retain': headDeleteSharedSurvives,
'head_delete_releases_ownership': true,
'head_delete_shared_survives': headDeleteSharedSurvives,
'stack_delete_completed':
ownershipGraph.arena.isDisposed &&
ownershipGraph.arena.nodeCount == 0 &&
ownershipGraph.arena.linkCount == 0,
'dot_success': true,
'dot_header': dot.startsWith('digraph stack {\n'),
'dot_rank': dot.contains('rankdir="RL";'),
'dot_active_head': dot.contains('node_head_0'),
'dot_paused_head':
dot.contains('node_head_1') && dot.contains('color=red'),
'dot_halted_omitted': !dot.contains('node_head_2'),
'dot_pending_link': dot.contains('style=dashed'),
};
return <String, Object?>{
'lifecycle': Map<String, Object?>.unmodifiable(result),
'version_operations': Map<String, Object?>.unmodifiable(
versionOperations,
),
'remaining_operations': Map<String, Object?>.unmodifiable(
remainingOperations,
),
};
} finally {
_activeGss = previousGraph;
}
}