treeSitterSubtreeHeader025ParityProbe function

Map<String, Object?> treeSitterSubtreeHeader025ParityProbe()

Direct managed semantic transcript for every inline helper in the pinned Tree-sitter 0.25.10 subtree.h.

Native SubtreeInlineData, SubtreeHeapData, Subtree, and MutableSubtree are storage optimizations. The managed runtime collapses those layouts into immutable GeneratedTreeSitterNode values, owns scanner bytes with unmodifiable lists, owns subtree arrays with Dart lists, and relies on GC instead of SubtreePool. This probe records all behavior that survives that intentional layout/ownership adaptation.

Implementation

Map<String, Object?> treeSitterSubtreeHeader025ParityProbe() {
  const zero = TreeSitterTablePoint(0, 0);
  TreeSitterTablePoint column(int value) => TreeSitterTablePoint(0, value);

  GeneratedTreeSitterNode leaf({
    required int symbol,
    required String type,
    required int start,
    required int size,
    int padding = 0,
    int lookahead = 0,
    int parseState = 7,
    bool named = false,
    bool visible = true,
    bool extra = false,
    bool missing = false,
    bool keyword = false,
    bool external = false,
    bool fragile = false,
    int? unexpected,
    List<int> scannerBefore = const <int>[],
    List<int> scannerAfter = const <int>[],
  }) => GeneratedTreeSitterNode(
    symbol: symbol,
    type: type,
    startByte: start,
    endByte: start + size,
    startPoint: column(start),
    endPoint: column(start + size),
    named: named,
    visible: visible,
    extra: extra,
    missing: missing,
    missingNameIsNamed: named,
    unexpectedCharacter: unexpected,
    parseState: parseState,
    firstLeafSymbol: symbol,
    firstLeafParseState: parseState,
    paddingBytes: padding,
    paddingExtent: column(padding),
    sizeBytes: size,
    sizeExtent: column(size),
    lookaheadBytes: lookahead,
    fragileLeft: fragile,
    fragileRight: fragile,
    isKeyword: keyword,
    hasExternalTokens: external,
    externalScannerStateBefore: scannerBefore,
    externalScannerStateAfter: scannerAfter,
  );

  final inline = leaf(
    symbol: 2,
    type: 'identifier',
    start: 2,
    size: 3,
    padding: 2,
    lookahead: 4,
    named: true,
    keyword: true,
  );
  final anonymous = leaf(symbol: 1, type: '+', start: 5, size: 1);
  final missing = leaf(
    symbol: 1,
    type: '+',
    start: 1,
    size: 0,
    padding: 1,
    lookahead: 2,
    missing: true,
  );
  final heapErrorLeaf = leaf(
    symbol: _treeSitterBuiltinErrorSymbol,
    type: 'ERROR',
    start: 0,
    size: 1,
    parseState: 5,
    named: true,
    fragile: true,
    unexpected: 10,
  );
  final external = leaf(
    symbol: 2,
    type: 'identifier',
    start: 0,
    size: 1,
    named: true,
    external: true,
    scannerAfter: List<int>.generate(21, (index) => index),
  );
  final eof = leaf(symbol: 0, type: 'end', start: 0, size: 0);
  final parentTemplate = GeneratedTreeSitterNode(
    symbol: 3,
    type: 'wrapper',
    startByte: 0,
    endByte: 0,
    startPoint: zero,
    endPoint: zero,
    named: false,
    visible: false,
    extra: false,
    productionId: 9,
  );
  final summarized = parentTemplate.summarizedWithChildren([inline, anonymous]);
  final parent = GeneratedTreeSitterNode(
    symbol: summarized.symbol,
    type: summarized.type,
    startByte: summarized.startByte,
    endByte: summarized.endByte,
    startPoint: summarized.startPoint,
    endPoint: summarized.endPoint,
    named: summarized.named,
    visible: summarized.visible,
    extra: summarized.extra,
    productionId: 9,
    dynamicPrecedence: 6,
    children: summarized.children,
    parseState: summarized.parseState,
    firstLeafSymbol: summarized.firstLeafSymbol,
    firstLeafParseState: summarized.firstLeafParseState,
    paddingBytes: summarized.paddingBytes,
    paddingExtent: summarized.paddingExtent,
    sizeBytes: summarized.sizeBytes,
    sizeExtent: summarized.sizeExtent,
    lookaheadBytes: summarized.lookaheadBytes,
  );
  final repeatTemplate = GeneratedTreeSitterNode(
    symbol: 4,
    type: 'repeat',
    startByte: 0,
    endByte: 0,
    startPoint: zero,
    endPoint: zero,
    named: false,
    visible: false,
    extra: false,
  );
  final repeat = generatedSubtreeCompress(
    repeatTemplate.summarizedWithChildren([
      repeatTemplate.summarizedWithChildren([
        repeatTemplate.summarizedWithChildren([inline, inline]),
        inline,
      ]),
      inline,
    ]),
    4,
  );
  final inlineTotalExtent = _addTablePoint(
    inline.paddingExtent,
    inline.sizeExtent,
  );
  final mutableInline = GeneratedTreeSitterNode(
    symbol: inline.symbol,
    type: inline.type,
    startByte: inline.startByte,
    endByte: inline.endByte,
    startPoint: inline.startPoint,
    endPoint: inline.endPoint,
    named: inline.named,
    visible: inline.visible,
    extra: true,
    parseState: inline.parseState,
    firstLeafSymbol: inline.firstLeafSymbol,
    firstLeafParseState: inline.firstLeafParseState,
    paddingBytes: inline.paddingBytes,
    paddingExtent: inline.paddingExtent,
    sizeBytes: inline.sizeBytes,
    sizeExtent: inline.sizeExtent,
    lookaheadBytes: inline.lookaheadBytes,
    isKeyword: inline.isKeyword,
  );
  final mutableParent = GeneratedTreeSitterNode(
    symbol: parent.symbol,
    type: parent.type,
    startByte: parent.startByte,
    endByte: parent.endByte,
    startPoint: parent.startPoint,
    endPoint: parent.endPoint,
    named: parent.named,
    visible: parent.visible,
    extra: true,
    missing: true,
    productionId: parent.productionId,
    dynamicPrecedence: parent.dynamicPrecedence,
    children: parent.children,
    parseState: 6,
    firstLeafSymbol: parent.firstLeafSymbol,
    firstLeafParseState: parent.firstLeafParseState,
    paddingBytes: parent.paddingBytes,
    paddingExtent: parent.paddingExtent,
    sizeBytes: parent.sizeBytes,
    sizeExtent: parent.sizeExtent,
    lookaheadBytes: parent.lookaheadBytes,
    hasChanges: true,
    dependsOnColumn: true,
  );

  bool isRepetition(GeneratedTreeSitterNode node) =>
      !node.named && !node.visible && node.children.isNotEmpty;
  bool scannerStateChanged(GeneratedTreeSitterNode node) =>
      !generatedSubtreeExternalScannerStateEquals(
        node.externalScannerStateBefore,
        node.externalScannerStateAfter,
      );

  return Map<String, Object?>.unmodifiable({
    'header.inline.symbol': inline.symbol,
    'header.inline.visible': inline.visible,
    'header.inline.named': inline.named,
    'header.inline.extra': inline.extra,
    'header.inline.has_changes': inline.hasChanges,
    'header.inline.missing': inline.missing,
    'header.inline.keyword': inline.isKeyword,
    'header.inline.parse_state': inline.parseState,
    'header.inline.lookahead': inline.lookaheadBytes,
    'header.inline.padding.bytes': inline.paddingBytes,
    'header.inline.padding.row': inline.paddingExtent.row,
    'header.inline.padding.column': inline.paddingExtent.column,
    'header.inline.size.bytes': inline.sizeBytes,
    'header.inline.size.row': inline.sizeExtent.row,
    'header.inline.size.column': inline.sizeExtent.column,
    'header.inline.total.bytes': inline.paddingBytes + inline.sizeBytes,
    'header.inline.total.row': inlineTotalExtent.row,
    'header.inline.total.column': inlineTotalExtent.column,
    'header.inline.total_bytes': inline.paddingBytes + inline.sizeBytes,
    'header.inline.child_count': inline.children.length,
    'header.inline.repeat_depth': generatedSubtreeRepeatDepth(inline),
    'header.inline.repetition': isRepetition(inline) ? 1 : 0,
    'header.inline.visible_descendants': inline.visibleDescendantCount,
    'header.inline.visible_children': 0,
    'header.inline.error_cost': inline.errorCost,
    'header.inline.dynamic_precedence': inline.dynamicPrecedence,
    'header.inline.production_id': inline.productionId,
    'header.inline.fragile_left': inline.fragileLeft,
    'header.inline.fragile_right': inline.fragileRight,
    'header.inline.external_tokens': inline.hasExternalTokens,
    'header.inline.external_state_change': scannerStateChanged(inline),
    'header.inline.depends_on_column': inline.dependsOnColumn,
    'header.inline.fragile': inline.fragileLeft || inline.fragileRight,
    'header.inline.error': inline.isError,
    'header.inline.eof': inline.symbol == 0,
    'header.inline.leaf_symbol': inline.firstLeafSymbol ?? inline.symbol,
    'header.inline.leaf_parse_state': inline.firstLeafParseState,
    'header.heap.symbol': mutableParent.symbol,
    'header.heap.visible': mutableParent.visible,
    'header.heap.named': mutableParent.named,
    'header.heap.extra': mutableParent.extra,
    'header.heap.has_changes': mutableParent.hasChanges,
    'header.heap.missing': mutableParent.missing,
    'header.heap.keyword': mutableParent.isKeyword,
    'header.heap.parse_state': mutableParent.parseState,
    'header.heap.lookahead': mutableParent.lookaheadBytes,
    'header.heap.depends_on_column': mutableParent.dependsOnColumn,
    'header.heap.padding.bytes': mutableParent.paddingBytes,
    'header.heap.size.bytes': mutableParent.sizeBytes,
    'header.heap.total.bytes':
        mutableParent.paddingBytes + mutableParent.sizeBytes,
    'header.heap.total_bytes':
        mutableParent.paddingBytes + mutableParent.sizeBytes,
    'header.heap_leaf.leaf_symbol':
        heapErrorLeaf.firstLeafSymbol ?? heapErrorLeaf.symbol,
    'header.heap_leaf.leaf_parse_state': heapErrorLeaf.firstLeafParseState,
    'header.parent.child_count': parent.children.length,
    'header.parent.leaf_symbol': parent.firstLeafSymbol ?? parent.symbol,
    'header.parent.leaf_parse_state': parent.firstLeafParseState,
    'header.parent.repeat_depth': generatedSubtreeRepeatDepth(repeat),
    'header.parent.repetition': isRepetition(repeat) ? 1 : 0,
    'header.parent.visible_descendants': parent.visibleDescendantCount,
    'header.parent.visible_children': parent.children
        .where((child) => child.visible)
        .length,
    'header.parent.dynamic_precedence': parent.dynamicPrecedence,
    'header.parent.production_id': parent.productionId,
    'header.heap_leaf.error_cost': heapErrorLeaf.errorCost,
    'header.heap_leaf.fragile':
        heapErrorLeaf.fragileLeft || heapErrorLeaf.fragileRight,
    'header.heap_leaf.error': heapErrorLeaf.isError,
    'header.missing.error_cost': missing.errorCost,
    'header.eof.eof': eof.symbol == 0,
    'header.external.tokens': external.hasExternalTokens,
    'header.external.state_change': scannerStateChanged(external),
    'header.set_extra.inline': mutableInline.extra,
    'header.set_extra.heap': mutableParent.extra,
    // Native from/to-mut are pointer/union reinterpretations. Immutable
    // managed values preserve their full semantic payload instead.
    'header.from_mut.symbol': mutableInline.symbol,
    'header.to_mut.symbol': inline.symbol,
    'header.from_mut.heap_symbol': mutableParent.symbol,
    'header.to_mut.heap_symbol': parent.symbol,
  });
}