rewriter 0.2.1

Rust utilities for rewriting files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use crate::SpanDefault;
use crate::interface::Span;

#[cfg(feature = "__check-proc-macro2-spans")]
use std::sync::atomic::{AtomicUsize, Ordering};

mod impls;

use impls::CachingOffsetCalculator;

#[cfg(feature = "check-offsets")]
use impls::StatelessOffsetCalculator;

#[cfg(feature = "__check-proc-macro2-spans")]
static BASE_NEXT: AtomicUsize = AtomicUsize::new(0);

pub trait Interface<S: Span> {
    /// Returns the byte offset for `line_column`
    ///
    /// The second component (the `bool`) indicates whether all characters up to the offset are
    /// ASCII.
    fn offset_from_line_column(&mut self, line_column: S::LineColumn) -> (usize, bool);
}

#[derive(Debug)]
pub struct OffsetCalculator<'original, S: Span = SpanDefault> {
    caching: CachingOffsetCalculator<'original, S>,

    #[cfg(feature = "check-offsets")]
    stateless: StatelessOffsetCalculator<'original, S>,

    #[cfg(feature = "__check-proc-macro2-spans")]
    base: usize,
}

impl<'original, S: Span> OffsetCalculator<'original, S> {
    #[must_use]
    pub fn new(original: &'original str) -> Self {
        Self::new_private(original, true)
    }

    pub(crate) fn new_private(original: &'original str, with_line_history: bool) -> Self {
        let caching = if with_line_history {
            CachingOffsetCalculator::new(original)
        } else {
            CachingOffsetCalculator::without_line_history(original)
        };

        Self {
            caching,

            #[cfg(feature = "check-offsets")]
            stateless: StatelessOffsetCalculator::new(original),

            #[cfg(feature = "__check-proc-macro2-spans")]
            base: BASE_NEXT.fetch_add(1 + original.len(), Ordering::SeqCst),
        }
    }

    pub fn offsets_from_span(&mut self, span: &S) -> (usize, usize) {
        let (start, start_ascii) = self.offset_from_line_column(span.start());
        let (end, end_ascii) = self.offset_from_line_column(span.end());

        assert!(!end_ascii || start_ascii);

        // smoelius: `proc_macro2::Span`'s debug output doesn't seem to account for UTF-8.
        #[cfg(feature = "__check-proc-macro2-spans")]
        if end_ascii {
            let start = self.base + start;
            let end = self.base + end;
            assert_eq!(
                format!("{span:?}"),
                format!("bytes({}..{})", 1 + start, 1 + end),
                "self = {:#?}, span.start() = {:?}, span.end() = {:?}",
                self,
                span.start(),
                span.end(),
            );
        }

        (start, end)
    }
}

impl<S: Span> Interface<S> for OffsetCalculator<'_, S> {
    fn offset_from_line_column(&mut self, line_column: S::LineColumn) -> (usize, bool) {
        let (offset, ascii) = self.caching.offset_from_line_column(line_column);

        #[cfg(feature = "check-offsets")]
        {
            let (offset_comparator, ascii_comparator) =
                self.stateless.offset_from_line_column(line_column);
            assert_eq!(offset, offset_comparator, "failed for {line_column:?}");
            assert_eq!(ascii, ascii_comparator, "failed for {line_column:?}");
        }

        (offset, ascii)
    }
}