treeSitterStack025ParityProbe function

Map<String, Object?> treeSitterStack025ParityProbe()

Implementation

Map<String, Object?> treeSitterStack025ParityProbe() {
  const origin = TreeSitterTablePoint(0, 0);
  const afterFirst = TreeSitterTablePoint(0, 2);
  const afterExtra = TreeSitterTablePoint(0, 5);

  GeneratedTreeSitterNode leaf({
    required int symbol,
    required int startByte,
    required int endByte,
    required TreeSitterTablePoint startPoint,
    required TreeSitterTablePoint endPoint,
    required bool extra,
    required int dynamicPrecedence,
  }) => GeneratedTreeSitterNode(
    symbol: symbol,
    type: 'symbol_$symbol',
    startByte: startByte,
    endByte: endByte,
    startPoint: startPoint,
    endPoint: endPoint,
    named: true,
    visible: true,
    extra: extra,
    dynamicPrecedence: dynamicPrecedence,
  );

  _ParseStack initialStack({int partition = 0}) => _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,
  );

  _Frame firstFrame(int precedence) => _Frame(
    2,
    leaf(
      symbol: 10,
      startByte: 0,
      endByte: 2,
      startPoint: origin,
      endPoint: afterFirst,
      extra: false,
      dynamicPrecedence: precedence,
    ),
    extra: false,
    scannerState: Uint8List.fromList(const <int>[1, 2]),
  );

  final graph = _GssContext(nodeErrorCost: (node) => node.errorCost);
  final target = initialStack(partition: 1);
  final baseHead = graph.initialize(target);
  target.arenaHead = baseHead;
  final targetFirst = firstFrame(3);
  target.frames.add(targetFirst);
  final targetFirstHead = graph.push(
    predecessorHead: baseHead,
    frame: targetFirst,
    stack: target,
  )!;
  target
    ..arenaHead = targetFirstHead
    ..position = 2
    ..point = afterFirst
    ..scannerState = Uint8List.fromList(const <int>[1, 2]);
  final extraFrame = _Frame(
    3,
    leaf(
      symbol: 11,
      startByte: 2,
      endByte: 5,
      startPoint: afterFirst,
      endPoint: afterExtra,
      extra: true,
      dynamicPrecedence: 0,
    ),
    extra: true,
    scannerState: Uint8List.fromList(const <int>[9]),
  );
  target.frames.add(extraFrame);
  final targetHead = graph.push(
    predecessorHead: targetFirstHead,
    frame: extraFrame,
    stack: target,
  )!;
  target
    ..arenaHead = targetHead
    ..position = 5
    ..point = afterExtra
    ..scannerState = Uint8List.fromList(const <int>[9]);

  // Build a merge-compatible version whose first subtree has higher dynamic
  // precedence. Native `stack_node_add_link` recursively merges its distinct
  // predecessor and raises the retained head's cumulative precedence.
  final source = initialStack(partition: 2);
  source.arenaHead = baseHead;
  final sourceFirst = firstFrame(7);
  source.frames.add(sourceFirst);
  final sourceFirstHead = graph.push(
    predecessorHead: baseHead,
    frame: sourceFirst,
    stack: source,
  )!;
  source
    ..arenaHead = sourceFirstHead
    ..position = 2
    ..point = afterFirst
    ..scannerState = Uint8List.fromList(const <int>[1, 2]);
  source.frames.add(extraFrame);
  final sourceHead = graph.push(
    predecessorHead: sourceFirstHead,
    frame: extraFrame,
    stack: source,
  )!;
  source
    ..arenaHead = sourceHead
    ..position = 5
    ..point = afterExtra
    ..scannerState = Uint8List.fromList(const <int>[9]);

  final targetBeforeMergePrecedence = graph.arena
      .payloadOf(targetHead)
      .dynamicPrecedence;
  graph.mergeHeadInto(target: targetHead, source: sourceHead);
  final summary = graph.summarize(targetHead, maxDepth: 4);
  final pop = graph.popSubtrees(targetHead, 1);

  final copied = target.copy();
  final originalScannerBeforeCopyMutation = List<int>.of(target.scannerState);
  copied.scannerState[0] = 42;
  final firstSlot = _VersionSlot(id: 0, stack: target);
  final secondSlot = _VersionSlot(id: 1, stack: copied);
  secondSlot.replace(
    copied,
    withStatus: _ParseStackStatus.paused,
    lookahead: null,
  );
  firstSlot.status = _ParseStackStatus.halted;

  return Map<String, Object?>.unmodifiable({
    'ts_stack_new.base_state': graph.arena.stateOf(baseHead),
    'ts_stack_new.base_position': graph.arena.positionOf(baseHead),
    'ts_stack_push.state': graph.arena.stateOf(targetHead),
    'ts_stack_push.position': graph.arena.positionOf(targetHead),
    'ts_stack_push.node_count': graph.arena.payloadOf(targetHead).nodeCount,
    'ts_stack_dynamic_precedence.before_merge': targetBeforeMergePrecedence,
    'ts_stack_dynamic_precedence.after_merge': graph.arena
        .payloadOf(targetHead)
        .dynamicPrecedence,
    'ts_stack_error_cost': graph.arena.payloadOf(targetHead).errorCost,
    'ts_stack_state': target.frames.last.state,
    'ts_stack_position': target.position,
    'ts_stack_last_external_token': List<int>.of(target.scannerState),
    'ts_stack_copy_version.scanner_isolated': target.scannerState[0] == 9,
    'ts_stack_copy_version.original_scanner': originalScannerBeforeCopyMutation,
    'ts_stack_halted_version_count': [
      firstSlot,
      secondSlot,
    ].where((slot) => slot.status == _ParseStackStatus.halted).length,
    'ts_stack_is_active': target.status == _ParseStackStatus.active,
    'ts_stack_is_halted': firstSlot.status == _ParseStackStatus.halted,
    'ts_stack_is_paused': secondSlot.status == _ParseStackStatus.paused,
    'ts_stack_version_count': 2,
    'ts_stack_record_summary': [
      for (final entry in summary)
        '${entry.state}:${entry.position}:${entry.depth}',
    ],
    'ts_stack_pop_count': [
      for (final path in pop)
        {
          'predecessor_state': graph.arena.stateOf(path.predecessor),
          'frames': [for (final frame in path.frames) frame.state],
        },
    ],
    'ts_stack_merge.top_link_count': graph.arena.linkCountOf(targetHead),
    'ts_stack_merge.predecessor_link_count': graph.arena.linkCountOf(
      targetFirstHead,
    ),
    'stack__subtree_node_count': _generatedSubtreeNodeCount(targetFirst.node!),
    'stack__subtree_is_equivalent': _GssContext._framesMergeEquivalent(
      targetFirst,
      sourceFirst,
    ),
  });
}