rune/fmt/
mod.rs

Help
1//! Helper to format Rune code.
2
3#[cfg(test)]
4mod tests;
5
6mod format;
7mod output;
8
9use core::fmt;
10
11use crate::alloc;
12use crate::alloc::prelude::*;
13use crate::ast::Span;
14use crate::compile::{ParseOptionError, Result, WithSpan};
15use crate::grammar::{Node, Remaining, Stream, Tree};
16use crate::{Diagnostics, Options, SourceId, Sources};
17
18use self::output::Comments;
19pub(crate) use self::output::Formatter;
20
21const WS: &str = " ";
22const NL: &str = "\n";
23const NL_CHAR: char = '\n';
24const INDENT: &str = "    ";
25
26#[derive(Debug)]
27enum FormatErrorKind {
28    Build,
29    ParseOptionError(ParseOptionError),
30    Alloc(alloc::Error),
31}
32
33/// Error during formatting.
34#[non_exhaustive]
35pub struct FormatError {
36    kind: FormatErrorKind,
37}
38
39impl fmt::Debug for FormatError {
40    #[inline]
41    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
42        self.kind.fmt(f)
43    }
44}
45
46impl fmt::Display for FormatError {
47    #[inline]
48    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
49        match &self.kind {
50            FormatErrorKind::Build => write!(f, "Failed to format source"),
51            FormatErrorKind::ParseOptionError(error) => error.fmt(f),
52            FormatErrorKind::Alloc(error) => error.fmt(f),
53        }
54    }
55}
56
57impl From<ParseOptionError> for FormatError {
58    fn from(value: ParseOptionError) -> Self {
59        Self {
60            kind: FormatErrorKind::ParseOptionError(value),
61        }
62    }
63}
64
65impl From<alloc::Error> for FormatError {
66    fn from(value: alloc::Error) -> Self {
67        Self {
68            kind: FormatErrorKind::Alloc(value),
69        }
70    }
71}
72
73impl core::error::Error for FormatError {}
74
75/// Format the given source.
76pub fn prepare(sources: &Sources) -> Prepare<'_> {
77    Prepare {
78        sources,
79        options: None,
80        diagnostics: None,
81    }
82}
83
84/// A prepared formatting operation.
85///
86/// See [prepare].
87pub struct Prepare<'a> {
88    sources: &'a Sources,
89    options: Option<&'a Options>,
90    diagnostics: Option<&'a mut Diagnostics>,
91}
92
93impl<'a> Prepare<'a> {
94    /// Associate diagnostics with the build.
95    pub fn with_diagnostics(mut self, diagnostics: &'a mut Diagnostics) -> Self {
96        self.diagnostics = Some(diagnostics);
97        self
98    }
99
100    /// Associate options with the build.
101    pub fn with_options(mut self, options: &'a Options) -> Self {
102        self.options = Some(options);
103        self
104    }
105
106    /// Format the given sources.
107    pub fn format(self) -> Result<Vec<(SourceId, String)>, FormatError> {
108        let mut local;
109
110        let diagnostics = match self.diagnostics {
111            Some(diagnostics) => diagnostics,
112            None => {
113                local = Diagnostics::new();
114                &mut local
115            }
116        };
117
118        let default_options;
119
120        let options = match self.options {
121            Some(options) => options,
122            None => {
123                default_options = Options::from_default_env()?;
124                &default_options
125            }
126        };
127
128        let mut files = Vec::new();
129
130        for id in self.sources.source_ids() {
131            let Some(source) = self.sources.get(id) else {
132                continue;
133            };
134
135            match layout_source_with(source.as_str(), id, options, diagnostics) {
136                Ok(output) => {
137                    files.try_push((id, output))?;
138                }
139                Err(error) => {
140                    diagnostics.error(id, error)?;
141                }
142            }
143        }
144
145        if diagnostics.has_error() {
146            return Err(FormatError {
147                kind: FormatErrorKind::Build,
148            });
149        }
150
151        Ok(files)
152    }
153}
154
155/// Format the given source with the specified options.
156pub(crate) fn layout_source_with(
157    source: &str,
158    source_id: SourceId,
159    options: &Options,
160    diagnostics: &mut Diagnostics,
161) -> Result<String> {
162    let tree = crate::grammar::text(source_id, source)
163        .without_processing()
164        .include_whitespace()
165        .root()?;
166
167    #[cfg(feature = "std")]
168    if options.print_tree {
169        tree.print_with_source(
170            &Span::empty(),
171            format_args!("Formatting source #{source_id}"),
172            source,
173        )?;
174    }
175
176    let mut o = String::new();
177
178    {
179        let mut o = Formatter::new(
180            Span::new(0, 0),
181            source,
182            source_id,
183            &mut o,
184            &options.fmt,
185            diagnostics,
186        );
187
188        o.flush_prefix_comments(&tree)?;
189        format::root(&mut o, &tree)?;
190        o.comments(Comments::Line)?;
191    }
192
193    if options.fmt.force_newline && !o.ends_with(NL) {
194        o.try_push_str(NL)
195            .with_span(Span::new(source.len(), source.len()))?;
196    }
197
198    Ok(o)
199}
rune/fmt/mod.rs

rune/fmt/
mod.rs
