swayfmt 0.62.0

Sway language formatter.
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
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
142
143
144
145
146
147
148
149
150
151

use self::shape::Shape;
use crate::comments::{write_comments, CommentsContext};
use crate::parse::parse_file;
use crate::utils::map::comments::CommentMap;
use crate::utils::map::{newline::handle_newlines, newline_style::apply_newline_style};
pub use crate::{
    config::manifest::Config,
    error::{ConfigError, FormatterError},
};
use std::{borrow::Cow, fmt::Write, path::Path, sync::Arc};
use sway_core::BuildConfig;
use sway_types::{SourceEngine, Spanned};

pub(crate) mod shape;

#[derive(Debug, Default, Clone)]
pub struct Formatter {
    pub source_engine: Arc<SourceEngine>,
    pub shape: Shape,
    pub config: Config,
    pub comments_context: CommentsContext,
}

pub type FormattedCode = String;

pub trait Format {
    fn format(
        &self,
        formatted_code: &mut FormattedCode,
        formatter: &mut Formatter,
    ) -> Result<(), FormatterError>;
}

impl Formatter {
    pub fn from_dir(dir: &Path) -> Result<Self, ConfigError> {
        let config = match Config::from_dir(dir) {
            Ok(config) => config,
            Err(ConfigError::NotFound) => Config::default(),
            Err(e) => return Err(e),
        };

        Ok(Self {
            config,
            ..Default::default()
        })
    }

    /// Adds a block to the indentation level of the current [`Shape`].
    pub fn indent(&mut self) {
        self.shape.block_indent(&self.config);
    }

    /// Removes a block from the indentation level of the current [`Shape`].
    pub fn unindent(&mut self) {
        self.shape.block_unindent(&self.config);
    }

    /// Returns the [`Shape`]'s indentation blocks as a `Cow<'static, str>`.
    pub fn indent_to_str(&self) -> Result<Cow<'static, str>, FormatterError> {
        self.shape.indent.to_string(&self.config)
    }

    /// Checks the current level of indentation before writing the indent str into the buffer.
    pub fn write_indent_into_buffer(
        &self,
        formatted_code: &mut FormattedCode,
    ) -> Result<(), FormatterError> {
        let indent_str = self.indent_to_str()?;
        if !formatted_code.ends_with(indent_str.as_ref()) {
            write!(formatted_code, "{indent_str}")?
        }
        Ok(())
    }

    /// Collect a mapping of Span -> Comment from unformatted input.
    pub fn with_comments_context(&mut self, src: &str) -> Result<&mut Self, FormatterError> {
        let comments_context =
            CommentsContext::new(CommentMap::from_src(Arc::from(src))?, src.to_string());
        self.comments_context = comments_context;
        Ok(self)
    }

    pub fn format(
        &mut self,
        src: Arc<str>,
        build_config: Option<&BuildConfig>,
    ) -> Result<FormattedCode, FormatterError> {
        // apply the width heuristics settings from the `Config`
        self.shape.apply_width_heuristics(
            self.config
                .heuristics
                .heuristics_pref
                .to_width_heuristics(self.config.whitespace.max_width),
        );
        let src = src.trim();

        let path = build_config.map(|build_config| build_config.canonical_root_module());
        // Formatted code will be pushed here with raw newline style.
        // Which means newlines are not converted into system-specific versions until `apply_newline_style()`.
        // Use the length of src as a hint of the memory size needed for `raw_formatted_code`,
        // which will reduce the number of reallocations
        let mut raw_formatted_code = String::with_capacity(src.len());

        self.with_comments_context(src)?;

        let annotated_module = parse_file(&self.source_engine, Arc::from(src), path.clone())?;
        annotated_module.format(&mut raw_formatted_code, self)?;

        let mut formatted_code = String::from(&raw_formatted_code);

        // Write post-module comments
        write_comments(
            &mut formatted_code,
            annotated_module.value.span().end()..src.len() + 1,
            self,
        )?;

        // Add newline sequences
        handle_newlines(
            &self.source_engine,
            Arc::from(src),
            &annotated_module.value,
            Arc::from(formatted_code.clone()),
            path,
            &mut formatted_code,
            self,
        )?;
        // Replace newlines with specified `NewlineStyle`
        apply_newline_style(
            self.config.whitespace.newline_style,
            &mut formatted_code,
            &raw_formatted_code,
        )?;
        if !formatted_code.ends_with('\n') {
            writeln!(formatted_code)?;
        }

        Ok(formatted_code)
    }
    pub(crate) fn with_shape<F, O>(&mut self, new_shape: Shape, f: F) -> O
    where
        F: FnOnce(&mut Self) -> O,
    {
        let prev_shape = self.shape;
        self.shape = new_shape;
        let output = f(self);
        self.shape = prev_shape;

        output // used to extract an output if needed
    }
}