Struct ParsedFile 

pub struct ParsedFile { /* private fields */ }

An immutable, owning parse result.

This value keeps the input bytes, lexer diagnostics, parser diagnostics, and compact CST together. Syntax errors do not make construction fail.

Implementations

impl ParsedFile

pub fn write_formatted<W: Write>( &self, sink: &mut W, options: FormatOptions, ) -> Result<(), FormatError>

Formats the retained assembly spelling while normalizing layout.

This method does not lower the file. Operation names, SSA names, aliases, comments, and custom assembly forms therefore remain source-derived.

pub fn formatted_bytes( &self, options: FormatOptions, ) -> Result<Vec<u8>, FormatError>

Returns source-aware formatted output as bytes.

impl ParsedFile

pub fn parse(bytes: impl Into<Arc<[u8]>>) -> Result<Self, ParseFileError>

Parses and owns bytes using default limits and generic operation syntax.

The result remains available for malformed MLIR; inspect Self::lexer_diagnostics and ParsedSyntax::diagnostics.

Errors

Returns an error when the source exceeds the file-size limit, cannot use compact offsets, or cannot be represented as a compact syntax tree.

Examples found in repository

examples/large_data_retention_benchmark.rs (line 60)

fn measure(elements: usize, profile: RetentionProfile) -> Measurement {
    let bytes = source(elements);
    let source_len = bytes.len();
    let parsed = ParsedFile::parse(bytes).expect("benchmark input parses");
    let started = Instant::now();
    let result = lower_with_dialect_registry_and_retention(
        &parsed,
        LoweringMode::Strict,
        profile,
        &DialectRegistry::EMPTY,
    );
    assert!(result.diagnostics.is_empty(), "{:?}", result.diagnostics);
    let document = result.document.expect("benchmark input lowers");
    document.validate().expect("benchmark document validates");
    let stats = document.statistics();
    assert_eq!(document.retention_profile(), profile);
    assert_eq!(
        stats.retained_source_bytes,
        match profile {
            RetentionProfile::SemanticOnly => 0,
            RetentionProfile::SyntaxOnly | RetentionProfile::Hybrid => source_len,
        }
    );
    assert_eq!(
        stats.retained_cst_nodes > 0,
        profile != RetentionProfile::SemanticOnly
    );
    assert_eq!(
        stats.retained_mapping_entries,
        match profile {
            RetentionProfile::Hybrid => 1,
            RetentionProfile::SyntaxOnly | RetentionProfile::SemanticOnly => 0,
        }
    );
    Measurement {
        source_bytes: source_len,
        semantic_attributes: stats.local_attributes,
        payload_bytes: stats.payload_blob_bytes,
        payload_blobs: stats.payload_blobs,
        cst_nodes: stats.retained_cst_nodes,
        mappings: stats.retained_mapping_entries,
        direct_owned_bytes: stats.direct_owned_bytes,
        document_index_bytes: stats.document_index_bytes,
        retained_cst_bytes: stats.retained_cst_bytes,
        source_shared: stats.source_storage_shared,
        cst_shared: stats.cst_storage_shared,
        lower_us: started.elapsed().as_micros(),
    }
}

examples/semantic_compaction_benchmark.rs (line 123)

fn measure(iterations: u32) -> Measurement {
    let registry = DialectRegistry::EMPTY;
    let parsed = ParsedFile::parse(br#"%0 = "anchor"() : () -> i32"#.as_slice()).unwrap();
    let mut document = lower_with_dialect_registry(&parsed, LoweringMode::Strict, &registry)
        .document
        .unwrap();
    let operation = document.root_operations()[0];
    let baseline = document.statistics();
    let allocator_baseline = LIVE_BYTES.load(Ordering::Relaxed);
    PEAK_BYTES.store(allocator_baseline, Ordering::Relaxed);
    let edit_start = Instant::now();
    let mut editor = document.edit(&registry).unwrap();
    for index in 0..iterations {
        let width = 33 + index;
        editor
            .replace_result_types(
                operation,
                &[TypeSpec {
                    spelling: format!("i{width}"),
                    value: TypeValue::Integer {
                        width,
                        signedness: None,
                    },
                }],
            )
            .unwrap();
        let name = format!("temporary_{index}");
        editor
            .set_attribute(
                operation,
                AttributeSpec::string(name.clone(), format!("value_{index}")),
            )
            .unwrap();
        editor.remove_attribute(operation, &name).unwrap();
    }
    editor
        .replace_result_types(
            operation,
            &[TypeSpec {
                spelling: "i32".into(),
                value: TypeValue::Integer {
                    width: 32,
                    signedness: None,
                },
            }],
        )
        .unwrap();
    let pooled_before = editor.document().statistics().pooled_list_entries;
    let reclaimed_list_entries = editor.compact_pools();
    editor.commit().unwrap();
    let edit_ns = edit_start.elapsed().as_nanos();
    let verify_start = Instant::now();
    black_box(document.verify_semantics(&registry)).unwrap();
    let verify_ns = verify_start.elapsed().as_nanos();
    let stats = document.statistics();
    assert_eq!(stats.live_attributes, 0);
    assert!(stats.retained_types > stats.live_types);
    assert!(stats.retained_attributes > stats.live_attributes);
    assert!(reclaimed_list_entries > 0 && stats.pooled_list_entries < pooled_before);
    Measurement {
        edit_ns,
        verify_ns,
        peak_allocated_bytes: PEAK_BYTES
            .load(Ordering::Relaxed)
            .saturating_sub(allocator_baseline) as usize,
        baseline_owned_bytes: baseline.direct_owned_bytes,
        stats,
        reclaimed_list_entries,
    }
}

pub fn parse_with_limits( bytes: impl Into<Arc<[u8]>>, limits: ParseLimits, ) -> Result<Self, ParseFileError>

Parses bytes with caller-supplied resource limits and generic syntax.

The same limits are retained for Self::apply_text_edits and semantic lowering. Recoverable lexer and syntax problems appear as diagnostics.

Errors

Returns the fatal errors described by Self::parse.

pub fn parse_with_registry( bytes: impl Into<Arc<[u8]>>, registry: &DialectRegistry, ) -> Result<Self, ParseFileError>

Parses bytes with default limits and registered custom operation syntax.

See the registry contract.

Pass the same registry to semantic lowering, verification, and custom printing so every stage uses the same dialect contract.

Errors

Returns the fatal errors described by Self::parse.

Examples found in repository

examples/diff_benchmark.rs (line 12)

fn lower(source: &str) -> Document {
    let registry = DialectRegistry::baseline();
    let parsed = ParsedFile::parse_with_registry(source.as_bytes(), registry).unwrap();
    lower_with_dialect_registry(&parsed, LoweringMode::Strict, registry)
        .document
        .expect("generated workload must lower strictly")
}

examples/indexing_editing_benchmark.rs (lines 25-28)

fn main() {
    let constants = OPERATIONS / 2;
    let mut source = String::from("builtin.module { func.func @bench() -> i32 {\n");
    for index in 0..constants {
        source.push_str(&format!("%v{index} = arith.constant {index} : i32\n"));
    }
    for index in constants..OPERATIONS {
        source.push_str(&format!(
            "%v{index} = arith.addi %v{}, %v0 : i32\n",
            index - 1
        ));
    }
    source.push_str(&format!("func.return %v{} : i32\n}} }}", OPERATIONS - 1));
    let start = Instant::now();
    let parsed = ParsedFile::parse_with_registry(
        Arc::<[u8]>::from(source.into_bytes()),
        DialectRegistry::baseline(),
    )
    .unwrap();
    let parse_ns = start.elapsed().as_nanos();
    let start = Instant::now();
    let mut document =
        lower_with_dialect_registry(&parsed, LoweringMode::Strict, DialectRegistry::baseline())
            .document
            .unwrap();
    let lower_ns = start.elapsed().as_nanos();
    let parse_only = document.statistics();

    let operations = document.operations().collect::<Vec<_>>();
    let first = operations
        .iter()
        .copied()
        .find(|operation| document.operation_name(*operation) == Some("arith.constant"))
        .unwrap();
    let first_value = document.operation(first).unwrap().result(first, 0).unwrap();
    let start = Instant::now();
    black_box(document.uses(first_value));
    let use_index_ns = start.elapsed().as_nanos();
    let start = Instant::now();
    black_box(document.symbol_index_diagnostics(DialectRegistry::baseline()));
    let symbol_index_ns = start.elapsed().as_nanos();
    let last = operations
        .iter()
        .copied()
        .rev()
        .find(|operation| document.operation_name(*operation) == Some("arith.addi"))
        .unwrap();
    let start = Instant::now();
    black_box(document.dominates(first_value, last, DialectRegistry::baseline()));
    let dominance_index_ns = start.elapsed().as_nanos();
    let indexed = document.statistics();
    let second = operations
        .iter()
        .copied()
        .filter(|operation| document.operation_name(*operation) == Some("arith.constant"))
        .nth(1)
        .unwrap();
    let mut editor = document.edit(DialectRegistry::baseline()).unwrap();
    let second_value = editor
        .document()
        .operation(second)
        .unwrap()
        .result(second, 0)
        .unwrap();
    for value in [second_value, first_value].into_iter().cycle().take(20) {
        editor.rewire_operand(last, 1, value).unwrap();
    }
    let before = editor.document().statistics().pooled_list_entries;
    let start = Instant::now();
    let reclaimed = editor.compact_pools();
    let compaction_ns = start.elapsed().as_nanos();
    editor.commit().unwrap();

    println!(
        "operations={OPERATIONS} parse_ns={parse_ns} lower_ns={lower_ns} parse_only_index_entries={} use_index_ns={use_index_ns} symbol_index_ns={symbol_index_ns} dominance_index_ns={dominance_index_ns} indexed_entries={} pooled_before={before} pooled_reclaimed={reclaimed} compaction_ns={compaction_ns}",
        parse_only.use_index_entries
            + parse_only.symbol_index_entries
            + parse_only.dominance_index_entries,
        indexed.use_index_entries + indexed.symbol_index_entries + indexed.dominance_index_entries,
    );
}

pub fn parse_with_limits_and_registry( bytes: impl Into<Arc<[u8]>>, limits: ParseLimits, registry: &DialectRegistry, ) -> Result<Self, ParseFileError>

Parses bytes with explicit limits and a dialect registry.

A successful result is lossless even when it contains diagnostics. Registered parse callbacks may add syntax errors but do not replace the generic recovery model.

Errors

Returns ParseFileError::ResourceLimit when max_file_bytes is exceeded, ParseFileError::Source when compact source offsets cannot represent the input, or ParseFileError::Syntax when CST compaction rejects the event stream.

Examples found in repository

examples/processing_benchmark.rs (lines 244-248)

fn measure(stage: Stage, shape: Shape, depth: Option<usize>, path: &PathBuf) -> Measurement {
    let registry = DialectRegistry::baseline();
    let mut limits = ParseLimits::default();
    if let Some(depth) = depth {
        limits.max_delimiter_depth = limits.max_delimiter_depth.max(depth.saturating_add(8));
    }
    let mut bytes = Vec::new();
    File::open(path).unwrap().read_to_end(&mut bytes).unwrap();
    let mut parsed = if stage == Stage::Parse {
        None
    } else {
        Some(
            ParsedFile::parse_with_limits_and_registry(
                Arc::<[u8]>::from(bytes.clone()),
                limits,
                registry,
            )
            .unwrap(),
        )
    };
    let retention = if shape == Shape::Primary
        && matches!(
            stage,
            Stage::Lower | Stage::Preserving | Stage::DirtyPreserving
        ) {
        RetentionProfile::Hybrid
    } else {
        RetentionProfile::SemanticOnly
    };
    let mut document = if matches!(
        stage,
        Stage::Lower
            | Stage::Parse
            | Stage::Traverse
            | Stage::SyntaxPayload
            | Stage::SyntaxOperationPayload
            | Stage::SyntaxOperationTraverse
    ) {
        None
    } else {
        Some(
            lower_with_dialect_registry_and_retention(
                parsed.as_ref().unwrap(),
                LoweringMode::Strict,
                retention,
                registry,
            )
            .document
            .expect("strict lowering"),
        )
    };
    if stage == Stage::DirtyPreserving {
        let document = document.as_mut().unwrap();
        let operations = document
            .operations()
            .filter(|operation| {
                document
                    .operation_regions(*operation)
                    .unwrap_or(&[])
                    .is_empty()
            })
            .collect::<Vec<_>>();
        let mut editor = document.edit(registry).unwrap();
        for operation in operations {
            editor
                .set_attribute(
                    operation,
                    AttributeSpec {
                        name: "bench_dirty".into(),
                        spelling: "\"yes\"".into(),
                        value: AttributeValue::String("\"yes\"".into()),
                    },
                )
                .unwrap();
        }
        editor.commit().unwrap();
    }
    let baseline = LIVE.load(Ordering::Relaxed);
    PEAK.store(baseline, Ordering::Relaxed);
    let started = Instant::now();
    let mut output = 0;
    let mut checksum = 0_u64;
    match stage {
        Stage::Parse => {
            parsed = Some(
                ParsedFile::parse_with_limits_and_registry(
                    Arc::<[u8]>::from(bytes),
                    limits,
                    registry,
                )
                .unwrap(),
            )
        }
        Stage::Traverse => {
            for node in parsed
                .as_ref()
                .unwrap()
                .syntax()
                .tree()
                .subtree(parsed.as_ref().unwrap().syntax().tree().root())
                .unwrap()
            {
                let tree = parsed.as_ref().unwrap().syntax().tree();
                checksum = checksum
                    .wrapping_mul(0x100000001b3)
                    .wrapping_add(tree.kind(node).unwrap() as u64)
                    .wrapping_add(tree.token_indices(node).unwrap().len() as u64);
            }
        }
        Stage::SyntaxPayload => {
            let tree = parsed.as_ref().unwrap().syntax().tree();
            let mut node_kind = Vec::with_capacity(tree.node_count() * 2);
            let mut node_start = Vec::with_capacity(tree.node_count() * 4);
            let mut node_end = Vec::with_capacity(tree.node_count() * 4);
            let mut node_subtree_end = Vec::with_capacity(tree.node_count() * 4);
            let mut node_flags = Vec::with_capacity(tree.node_count());
            for index in 0..tree.node_count() {
                let id = tree.node(index).unwrap();
                node_kind.extend_from_slice(&(tree.kind(id).unwrap() as u16).to_ne_bytes());
                node_start.extend_from_slice(
                    &tree
                        .text_range(id)
                        .map_or(u32::MAX, |r| r.start())
                        .to_ne_bytes(),
                );
                node_end.extend_from_slice(
                    &tree
                        .text_range(id)
                        .map_or(u32::MAX, |r| r.end())
                        .to_ne_bytes(),
                );
                node_subtree_end
                    .extend_from_slice(&(tree.subtree_end(id).unwrap() as u32).to_ne_bytes());
                node_flags.push(u8::from(tree.has_error(id).unwrap()));
            }
            let mut token_kind = Vec::with_capacity(tree.token_count() * 2);
            let mut token_start = Vec::with_capacity(tree.token_count() * 4);
            let mut token_end = Vec::with_capacity(tree.token_count() * 4);
            for index in 0..tree.token_count() {
                let token = tree.token(index).unwrap();
                token_kind.extend_from_slice(&(token.kind() as u16).to_ne_bytes());
                token_start.extend_from_slice(&token.range().start().to_ne_bytes());
                token_end.extend_from_slice(&token.range().end().to_ne_bytes());
            }
            output = node_kind.len()
                + node_start.len()
                + node_end.len()
                + node_subtree_end.len()
                + node_flags.len()
                + token_kind.len()
                + token_start.len()
                + token_end.len();
            checksum = node_kind
                .iter()
                .chain(&token_kind)
                .fold(0_u64, |sum, byte| sum.wrapping_add(*byte as u64));
            black_box((
                node_kind,
                node_start,
                node_end,
                node_subtree_end,
                node_flags,
                token_kind,
                token_start,
                token_end,
            ));
        }
        Stage::SyntaxOperationTraverse => {
            for operation in parsed.as_ref().unwrap().syntax().file().operations() {
                checksum = checksum
                    .wrapping_add(operation.id().index() as u64)
                    .wrapping_add(operation.results().count() as u64)
                    .wrapping_add(operation.operands().count() as u64)
                    .wrapping_add(operation.successors().count() as u64)
                    .wrapping_add(operation.regions().count() as u64);
            }
        }
        Stage::SyntaxOperationPayload => {
            let operations = parsed
                .as_ref()
                .unwrap()
                .syntax()
                .file()
                .operations()
                .collect::<Vec<_>>();
            let result_count = operations.iter().map(|op| op.results().count()).sum();
            let operand_count = operations.iter().map(|op| op.operands().count()).sum();
            let successor_count = operations.iter().map(|op| op.successors().count()).sum();
            let region_count = operations.iter().map(|op| op.regions().count()).sum();
            let mut columns = [
                Vec::with_capacity(operations.len()),
                Vec::with_capacity(operations.len() + 1),
                Vec::with_capacity(result_count),
                Vec::with_capacity(operations.len() + 1),
                Vec::with_capacity(operand_count),
                Vec::with_capacity(operations.len() + 1),
                Vec::with_capacity(successor_count),
                Vec::with_capacity(operations.len() + 1),
                Vec::with_capacity(region_count),
            ];
            for index in [1, 3, 5, 7] {
                columns[index].push(0);
            }
            for operation in operations {
                columns[0].push(operation.id().index() as u32);
                columns[2].extend(operation.results().map(|node| node.id().index() as u32));
                let end = columns[2].len() as u32;
                columns[1].push(end);
                columns[4].extend(operation.operands().map(|node| node.id().index() as u32));
                let end = columns[4].len() as u32;
                columns[3].push(end);
                columns[6].extend(operation.successors().map(|node| node.id().index() as u32));
                let end = columns[6].len() as u32;
                columns[5].push(end);
                columns[8].extend(operation.regions().map(|node| node.id().index() as u32));
                let end = columns[8].len() as u32;
                columns[7].push(end);
            }
            checksum = columns
                .iter()
                .flatten()
                .fold(0_u64, |sum, value| sum.wrapping_add(*value as u64));
            output = columns
                .iter()
                .map(|column| column.len() * size_of::<u32>())
                .sum();
            black_box(columns);
        }
        Stage::Lower => {
            document = Some(
                lower_with_dialect_registry_and_retention(
                    parsed.as_ref().unwrap(),
                    LoweringMode::Strict,
                    retention,
                    registry,
                )
                .document
                .expect("strict lowering"),
            )
        }
        Stage::OperationPayload => {
            let doc = document.as_ref().unwrap();
            let mut names = std::collections::HashMap::<u32, u32>::new();
            let mut distinct = Vec::new();
            let mut columns = Vec::<u32>::new();
            for id in doc.operations() {
                let stored = doc.operation_name_index(id).unwrap();
                let next = distinct.len() as u32;
                let code = *names.entry(stored).or_insert_with(|| {
                    distinct.push(stored);
                    next
                });
                let range = doc.operation_source_range(id).unwrap();
                columns.extend([code, range.start(), range.end()]);
                checksum = checksum.wrapping_add(code as u64);
            }
            let name_bytes: usize = distinct
                .iter()
                .map(|&index| doc.string_at(index).unwrap().len())
                .sum();
            output = columns.len() * std::mem::size_of::<u32>()
                + doc.operations().count()
                + (distinct.len() + 1) * std::mem::size_of::<u32>()
                + name_bytes;
            black_box(columns);
        }
        Stage::OperationTraverse => {
            let doc = document.as_ref().unwrap();
            for id in doc.operations() {
                checksum = checksum
                    .wrapping_add(doc.operation_name_index(id).unwrap() as u64)
                    .wrapping_add(doc.operation_source_range(id).unwrap().start() as u64);
            }
        }
        Stage::Verify => document
            .as_ref()
            .unwrap()
            .verify_semantics(registry)
            .unwrap(),
        Stage::Canonical => {
            let mut sink = ByteCounter::default();
            document
                .as_ref()
                .unwrap()
                .write_canonical(&mut sink, PrintLayout::Compact)
                .unwrap();
            output = sink.0;
        }
        Stage::UseIndex => {
            let doc = document.as_ref().unwrap();
            if let Some((_op, value)) = doc.operations().find_map(|op| {
                doc.operation(op)
                    .unwrap()
                    .result(op, 0)
                    .map(|value| (op, value))
            }) {
                black_box(doc.uses(value));
            }
        }
        Stage::SymbolIndex => {
            black_box(
                document
                    .as_ref()
                    .unwrap()
                    .symbol_index_diagnostics(registry),
            );
        }
        Stage::DominanceIndex => {
            let doc = document.as_ref().unwrap();
            let ops = doc.operations().collect::<Vec<_>>();
            if let (Some((_, value)), Some(last)) = (
                ops.iter().find_map(|op| {
                    doc.operation(*op)
                        .unwrap()
                        .result(*op, 0)
                        .map(|value| (*op, value))
                }),
                ops.last(),
            ) {
                black_box(doc.dominates(value, *last, registry));
            }
        }
        Stage::Editor => {
            let doc = document.as_mut().unwrap();
            let mut editor = doc.edit(registry).unwrap();
            if shape == Shape::BlockRich {
                black_box(editor.compact_pools());
            } else {
                let leaf = editor
                    .document()
                    .operations()
                    .find(|op| editor.document().operation_name(*op) == Some("bench.op"))
                    .expect("editable leaf");
                editor.erase(leaf).unwrap();
            }
            editor.commit().unwrap();
        }
        Stage::Preserving | Stage::DirtyPreserving => {
            let doc = document.as_ref().unwrap();
            let mut sink = ByteCounter::default();
            doc.write_preserving(&mut sink, PrintLayout::Compact)
                .unwrap();
            output = sink.0;
        }
    }
    let elapsed = started.elapsed();
    let peak = PEAK.load(Ordering::Relaxed).saturating_sub(baseline) as usize;
    let stats = document.as_ref().map(|doc| { let s=doc.statistics(); format!("operations={} regions={} blocks={} pooled_entries={} direct_owned_bytes={} document_index_bytes={} retained_source_bytes={} retained_cst_nodes={} retained_cst_bytes={} source_storage_shared={} cst_storage_shared={} retained_mapping_entries={} payload_blob_bytes={} use_index_entries={} symbol_index_entries={} dominance_index_entries={}",s.operations,s.regions,s.blocks,s.pooled_list_entries,s.direct_owned_bytes,s.document_index_bytes,s.retained_source_bytes,s.retained_cst_nodes,s.retained_cst_bytes,s.source_storage_shared,s.cst_storage_shared,s.retained_mapping_entries,s.payload_blob_bytes,s.use_index_entries,s.symbol_index_entries,s.dominance_index_entries) }).unwrap_or_else(|| { let tree=parsed.as_ref().map(|p|p.syntax().tree()); format!("cst_nodes={} cst_tokens={} exact_cst_retained_bytes={}",tree.map_or(0,|t|t.node_count()),tree.map_or(0,|t|t.token_count()),tree.map_or(0,|t|t.exact_retained_bytes())) });
    black_box(checksum);
    Measurement {
        ns: elapsed.as_nanos(),
        peak,
        output,
        checksum,
        stats,
    }
}

pub fn source(&self) -> &Source

pub fn lexer_diagnostics(&self) -> &[LexDiagnostic]

pub fn syntax(&self) -> &ParsedSyntax

Examples found in repository

examples/processing_benchmark.rs (line 329)

fn measure(stage: Stage, shape: Shape, depth: Option<usize>, path: &PathBuf) -> Measurement {
    let registry = DialectRegistry::baseline();
    let mut limits = ParseLimits::default();
    if let Some(depth) = depth {
        limits.max_delimiter_depth = limits.max_delimiter_depth.max(depth.saturating_add(8));
    }
    let mut bytes = Vec::new();
    File::open(path).unwrap().read_to_end(&mut bytes).unwrap();
    let mut parsed = if stage == Stage::Parse {
        None
    } else {
        Some(
            ParsedFile::parse_with_limits_and_registry(
                Arc::<[u8]>::from(bytes.clone()),
                limits,
                registry,
            )
            .unwrap(),
        )
    };
    let retention = if shape == Shape::Primary
        && matches!(
            stage,
            Stage::Lower | Stage::Preserving | Stage::DirtyPreserving
        ) {
        RetentionProfile::Hybrid
    } else {
        RetentionProfile::SemanticOnly
    };
    let mut document = if matches!(
        stage,
        Stage::Lower
            | Stage::Parse
            | Stage::Traverse
            | Stage::SyntaxPayload
            | Stage::SyntaxOperationPayload
            | Stage::SyntaxOperationTraverse
    ) {
        None
    } else {
        Some(
            lower_with_dialect_registry_and_retention(
                parsed.as_ref().unwrap(),
                LoweringMode::Strict,
                retention,
                registry,
            )
            .document
            .expect("strict lowering"),
        )
    };
    if stage == Stage::DirtyPreserving {
        let document = document.as_mut().unwrap();
        let operations = document
            .operations()
            .filter(|operation| {
                document
                    .operation_regions(*operation)
                    .unwrap_or(&[])
                    .is_empty()
            })
            .collect::<Vec<_>>();
        let mut editor = document.edit(registry).unwrap();
        for operation in operations {
            editor
                .set_attribute(
                    operation,
                    AttributeSpec {
                        name: "bench_dirty".into(),
                        spelling: "\"yes\"".into(),
                        value: AttributeValue::String("\"yes\"".into()),
                    },
                )
                .unwrap();
        }
        editor.commit().unwrap();
    }
    let baseline = LIVE.load(Ordering::Relaxed);
    PEAK.store(baseline, Ordering::Relaxed);
    let started = Instant::now();
    let mut output = 0;
    let mut checksum = 0_u64;
    match stage {
        Stage::Parse => {
            parsed = Some(
                ParsedFile::parse_with_limits_and_registry(
                    Arc::<[u8]>::from(bytes),
                    limits,
                    registry,
                )
                .unwrap(),
            )
        }
        Stage::Traverse => {
            for node in parsed
                .as_ref()
                .unwrap()
                .syntax()
                .tree()
                .subtree(parsed.as_ref().unwrap().syntax().tree().root())
                .unwrap()
            {
                let tree = parsed.as_ref().unwrap().syntax().tree();
                checksum = checksum
                    .wrapping_mul(0x100000001b3)
                    .wrapping_add(tree.kind(node).unwrap() as u64)
                    .wrapping_add(tree.token_indices(node).unwrap().len() as u64);
            }
        }
        Stage::SyntaxPayload => {
            let tree = parsed.as_ref().unwrap().syntax().tree();
            let mut node_kind = Vec::with_capacity(tree.node_count() * 2);
            let mut node_start = Vec::with_capacity(tree.node_count() * 4);
            let mut node_end = Vec::with_capacity(tree.node_count() * 4);
            let mut node_subtree_end = Vec::with_capacity(tree.node_count() * 4);
            let mut node_flags = Vec::with_capacity(tree.node_count());
            for index in 0..tree.node_count() {
                let id = tree.node(index).unwrap();
                node_kind.extend_from_slice(&(tree.kind(id).unwrap() as u16).to_ne_bytes());
                node_start.extend_from_slice(
                    &tree
                        .text_range(id)
                        .map_or(u32::MAX, |r| r.start())
                        .to_ne_bytes(),
                );
                node_end.extend_from_slice(
                    &tree
                        .text_range(id)
                        .map_or(u32::MAX, |r| r.end())
                        .to_ne_bytes(),
                );
                node_subtree_end
                    .extend_from_slice(&(tree.subtree_end(id).unwrap() as u32).to_ne_bytes());
                node_flags.push(u8::from(tree.has_error(id).unwrap()));
            }
            let mut token_kind = Vec::with_capacity(tree.token_count() * 2);
            let mut token_start = Vec::with_capacity(tree.token_count() * 4);
            let mut token_end = Vec::with_capacity(tree.token_count() * 4);
            for index in 0..tree.token_count() {
                let token = tree.token(index).unwrap();
                token_kind.extend_from_slice(&(token.kind() as u16).to_ne_bytes());
                token_start.extend_from_slice(&token.range().start().to_ne_bytes());
                token_end.extend_from_slice(&token.range().end().to_ne_bytes());
            }
            output = node_kind.len()
                + node_start.len()
                + node_end.len()
                + node_subtree_end.len()
                + node_flags.len()
                + token_kind.len()
                + token_start.len()
                + token_end.len();
            checksum = node_kind
                .iter()
                .chain(&token_kind)
                .fold(0_u64, |sum, byte| sum.wrapping_add(*byte as u64));
            black_box((
                node_kind,
                node_start,
                node_end,
                node_subtree_end,
                node_flags,
                token_kind,
                token_start,
                token_end,
            ));
        }
        Stage::SyntaxOperationTraverse => {
            for operation in parsed.as_ref().unwrap().syntax().file().operations() {
                checksum = checksum
                    .wrapping_add(operation.id().index() as u64)
                    .wrapping_add(operation.results().count() as u64)
                    .wrapping_add(operation.operands().count() as u64)
                    .wrapping_add(operation.successors().count() as u64)
                    .wrapping_add(operation.regions().count() as u64);
            }
        }
        Stage::SyntaxOperationPayload => {
            let operations = parsed
                .as_ref()
                .unwrap()
                .syntax()
                .file()
                .operations()
                .collect::<Vec<_>>();
            let result_count = operations.iter().map(|op| op.results().count()).sum();
            let operand_count = operations.iter().map(|op| op.operands().count()).sum();
            let successor_count = operations.iter().map(|op| op.successors().count()).sum();
            let region_count = operations.iter().map(|op| op.regions().count()).sum();
            let mut columns = [
                Vec::with_capacity(operations.len()),
                Vec::with_capacity(operations.len() + 1),
                Vec::with_capacity(result_count),
                Vec::with_capacity(operations.len() + 1),
                Vec::with_capacity(operand_count),
                Vec::with_capacity(operations.len() + 1),
                Vec::with_capacity(successor_count),
                Vec::with_capacity(operations.len() + 1),
                Vec::with_capacity(region_count),
            ];
            for index in [1, 3, 5, 7] {
                columns[index].push(0);
            }
            for operation in operations {
                columns[0].push(operation.id().index() as u32);
                columns[2].extend(operation.results().map(|node| node.id().index() as u32));
                let end = columns[2].len() as u32;
                columns[1].push(end);
                columns[4].extend(operation.operands().map(|node| node.id().index() as u32));
                let end = columns[4].len() as u32;
                columns[3].push(end);
                columns[6].extend(operation.successors().map(|node| node.id().index() as u32));
                let end = columns[6].len() as u32;
                columns[5].push(end);
                columns[8].extend(operation.regions().map(|node| node.id().index() as u32));
                let end = columns[8].len() as u32;
                columns[7].push(end);
            }
            checksum = columns
                .iter()
                .flatten()
                .fold(0_u64, |sum, value| sum.wrapping_add(*value as u64));
            output = columns
                .iter()
                .map(|column| column.len() * size_of::<u32>())
                .sum();
            black_box(columns);
        }
        Stage::Lower => {
            document = Some(
                lower_with_dialect_registry_and_retention(
                    parsed.as_ref().unwrap(),
                    LoweringMode::Strict,
                    retention,
                    registry,
                )
                .document
                .expect("strict lowering"),
            )
        }
        Stage::OperationPayload => {
            let doc = document.as_ref().unwrap();
            let mut names = std::collections::HashMap::<u32, u32>::new();
            let mut distinct = Vec::new();
            let mut columns = Vec::<u32>::new();
            for id in doc.operations() {
                let stored = doc.operation_name_index(id).unwrap();
                let next = distinct.len() as u32;
                let code = *names.entry(stored).or_insert_with(|| {
                    distinct.push(stored);
                    next
                });
                let range = doc.operation_source_range(id).unwrap();
                columns.extend([code, range.start(), range.end()]);
                checksum = checksum.wrapping_add(code as u64);
            }
            let name_bytes: usize = distinct
                .iter()
                .map(|&index| doc.string_at(index).unwrap().len())
                .sum();
            output = columns.len() * std::mem::size_of::<u32>()
                + doc.operations().count()
                + (distinct.len() + 1) * std::mem::size_of::<u32>()
                + name_bytes;
            black_box(columns);
        }
        Stage::OperationTraverse => {
            let doc = document.as_ref().unwrap();
            for id in doc.operations() {
                checksum = checksum
                    .wrapping_add(doc.operation_name_index(id).unwrap() as u64)
                    .wrapping_add(doc.operation_source_range(id).unwrap().start() as u64);
            }
        }
        Stage::Verify => document
            .as_ref()
            .unwrap()
            .verify_semantics(registry)
            .unwrap(),
        Stage::Canonical => {
            let mut sink = ByteCounter::default();
            document
                .as_ref()
                .unwrap()
                .write_canonical(&mut sink, PrintLayout::Compact)
                .unwrap();
            output = sink.0;
        }
        Stage::UseIndex => {
            let doc = document.as_ref().unwrap();
            if let Some((_op, value)) = doc.operations().find_map(|op| {
                doc.operation(op)
                    .unwrap()
                    .result(op, 0)
                    .map(|value| (op, value))
            }) {
                black_box(doc.uses(value));
            }
        }
        Stage::SymbolIndex => {
            black_box(
                document
                    .as_ref()
                    .unwrap()
                    .symbol_index_diagnostics(registry),
            );
        }
        Stage::DominanceIndex => {
            let doc = document.as_ref().unwrap();
            let ops = doc.operations().collect::<Vec<_>>();
            if let (Some((_, value)), Some(last)) = (
                ops.iter().find_map(|op| {
                    doc.operation(*op)
                        .unwrap()
                        .result(*op, 0)
                        .map(|value| (*op, value))
                }),
                ops.last(),
            ) {
                black_box(doc.dominates(value, *last, registry));
            }
        }
        Stage::Editor => {
            let doc = document.as_mut().unwrap();
            let mut editor = doc.edit(registry).unwrap();
            if shape == Shape::BlockRich {
                black_box(editor.compact_pools());
            } else {
                let leaf = editor
                    .document()
                    .operations()
                    .find(|op| editor.document().operation_name(*op) == Some("bench.op"))
                    .expect("editable leaf");
                editor.erase(leaf).unwrap();
            }
            editor.commit().unwrap();
        }
        Stage::Preserving | Stage::DirtyPreserving => {
            let doc = document.as_ref().unwrap();
            let mut sink = ByteCounter::default();
            doc.write_preserving(&mut sink, PrintLayout::Compact)
                .unwrap();
            output = sink.0;
        }
    }
    let elapsed = started.elapsed();
    let peak = PEAK.load(Ordering::Relaxed).saturating_sub(baseline) as usize;
    let stats = document.as_ref().map(|doc| { let s=doc.statistics(); format!("operations={} regions={} blocks={} pooled_entries={} direct_owned_bytes={} document_index_bytes={} retained_source_bytes={} retained_cst_nodes={} retained_cst_bytes={} source_storage_shared={} cst_storage_shared={} retained_mapping_entries={} payload_blob_bytes={} use_index_entries={} symbol_index_entries={} dominance_index_entries={}",s.operations,s.regions,s.blocks,s.pooled_list_entries,s.direct_owned_bytes,s.document_index_bytes,s.retained_source_bytes,s.retained_cst_nodes,s.retained_cst_bytes,s.source_storage_shared,s.cst_storage_shared,s.retained_mapping_entries,s.payload_blob_bytes,s.use_index_entries,s.symbol_index_entries,s.dominance_index_entries) }).unwrap_or_else(|| { let tree=parsed.as_ref().map(|p|p.syntax().tree()); format!("cst_nodes={} cst_tokens={} exact_cst_retained_bytes={}",tree.map_or(0,|t|t.node_count()),tree.map_or(0,|t|t.token_count()),tree.map_or(0,|t|t.exact_retained_bytes())) });
    black_box(checksum);
    Measurement {
        ns: elapsed.as_nanos(),
        peak,
        output,
        checksum,
        stats,
    }
}

pub fn max_attribute_depth(&self) -> usize

pub fn max_alias_expansion_depth(&self) -> usize

pub fn original_bytes(&self) -> &[u8]

pub fn write_original<W: Write>(&self, sink: &mut W) -> Result<()>

pub fn apply_text_edits( &self, edits: &[TextEdit], ) -> Result<Self, ApplyTextEditsError>

Applies non-overlapping byte-range edits and reparses the complete result.

Ranges refer to this file’s original bytes. The returned file preserves this file’s complete ParseLimits. This method reparses with the empty registry. For registered custom syntax, use Self::apply_text_edits_with_registry with the original registry.

Errors

Returns an error for an out-of-bounds or overlapping range, an unrepresentable output length, or a fatal error while reparsing.

pub fn apply_text_edits_with_registry( &self, edits: &[TextEdit], registry: &DialectRegistry, ) -> Result<Self, ApplyTextEditsError>

Applies text edits and reparses with explicit custom syntax.

See the registry contract.

Errors

Returns the same errors as Self::apply_text_edits.

Trait Implementations

impl Debug for ParsedFile

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.