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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
//! Source file management.
use std::fmt::{self, Debug, Formatter};
use std::hash::{Hash, Hasher};
use std::ops::Range;
use std::sync::Arc;
use typst_utils::LazyHash;
use crate::lines::Lines;
use crate::reparser::reparse;
use crate::{parse, FileId, LinkedNode, Span, SyntaxNode, VirtualPath};
/// A source file.
///
/// All line and column indices start at zero, just like byte indices. Only for
/// user-facing display, you should add 1 to them.
///
/// Values of this type are cheap to clone and hash.
#[derive(Clone)]
pub struct Source(Arc<Repr>);
/// The internal representation.
#[derive(Clone)]
struct Repr {
id: FileId,
root: LazyHash<SyntaxNode>,
lines: LazyHash<Lines<String>>,
}
impl Source {
/// Create a new source file.
pub fn new(id: FileId, text: String) -> Self {
let _scope = typst_timing::TimingScope::new("create source");
let mut root = parse(&text);
root.numberize(id, Span::FULL).unwrap();
Self(Arc::new(Repr {
id,
lines: LazyHash::new(Lines::new(text)),
root: LazyHash::new(root),
}))
}
/// Create a source file without a real id and path, usually for testing.
pub fn detached(text: impl Into<String>) -> Self {
Self::new(FileId::new(None, VirtualPath::new("main.typ")), text.into())
}
/// The root node of the file's untyped syntax tree.
pub fn root(&self) -> &SyntaxNode {
&self.0.root
}
/// The id of the source file.
pub fn id(&self) -> FileId {
self.0.id
}
/// The whole source as a string slice.
pub fn text(&self) -> &str {
self.0.lines.text()
}
/// An acceleration structure for conversion of UTF-8, UTF-16 and
/// line/column indices.
pub fn lines(&self) -> &Lines<String> {
&self.0.lines
}
/// Fully replace the source text.
///
/// This performs a naive (suffix/prefix-based) diff of the old and new text
/// to produce the smallest single edit that transforms old into new and
/// then calls [`edit`](Self::edit) with it.
///
/// Returns the range in the new source that was ultimately reparsed.
pub fn replace(&mut self, new: &str) -> Range<usize> {
let _scope = typst_timing::TimingScope::new("replace source");
let Some((prefix, suffix)) = self.0.lines.replacement_range(new) else {
return 0..0;
};
let old = self.text();
let replace = prefix..old.len() - suffix;
let with = &new[prefix..new.len() - suffix];
self.edit(replace, with)
}
/// Edit the source file by replacing the given range.
///
/// Returns the range in the new source that was ultimately reparsed.
///
/// The method panics if the `replace` range is out of bounds.
#[track_caller]
pub fn edit(&mut self, replace: Range<usize>, with: &str) -> Range<usize> {
let inner = Arc::make_mut(&mut self.0);
// Update the text and lines.
inner.lines.edit(replace.clone(), with);
// Incrementally reparse the replaced range.
reparse(&mut inner.root, inner.lines.text(), replace, with.len())
}
/// Find the node with the given span.
///
/// Returns `None` if the span does not point into this source file.
pub fn find(&self, span: Span) -> Option<LinkedNode<'_>> {
LinkedNode::new(self.root()).find(span)
}
/// Get the byte range for the given span in this file.
///
/// Returns `None` if the span does not point into this source file.
///
/// Typically, it's easier to use `WorldExt::range` instead.
pub fn range(&self, span: Span) -> Option<Range<usize>> {
Some(self.find(span)?.range())
}
}
impl Debug for Source {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
write!(f, "Source({:?})", self.id().vpath())
}
}
impl Hash for Source {
fn hash<H: Hasher>(&self, state: &mut H) {
self.0.id.hash(state);
self.0.lines.hash(state);
self.0.root.hash(state);
}
}
impl AsRef<str> for Source {
fn as_ref(&self) -> &str {
self.text()
}
}
|
