[rustc.git] / src / tools / rustfmt / src / shape.rs

use std::borrow::Cow;
use std::cmp::min;
use std::ops::{Add, Sub};

use crate::Config;

#[derive(Copy, Clone, Debug)]
pub(crate) struct Indent {
    // Width of the block indent, in characters. Must be a multiple of
    // Config::tab_spaces.
    pub(crate) block_indent: usize,
    // Alignment in characters.
    pub(crate) alignment: usize,
}

// INDENT_BUFFER.len() = 81
const INDENT_BUFFER_LEN: usize = 80;
const INDENT_BUFFER: &str =
    "\n                                                                                ";

impl Indent {
    pub(crate) fn new(block_indent: usize, alignment: usize) -> Indent {
        Indent {
            block_indent,
            alignment,
        }
    }

    pub(crate) fn from_width(config: &Config, width: usize) -> Indent {
        if config.hard_tabs() {
            let tab_num = width / config.tab_spaces();
            let alignment = width % config.tab_spaces();
            Indent::new(config.tab_spaces() * tab_num, alignment)
        } else {
            Indent::new(width, 0)
        }
    }

    pub(crate) fn empty() -> Indent {
        Indent::new(0, 0)
    }

    pub(crate) fn block_only(&self) -> Indent {
        Indent {
            block_indent: self.block_indent,
            alignment: 0,
        }
    }

    pub(crate) fn block_indent(mut self, config: &Config) -> Indent {
        self.block_indent += config.tab_spaces();
        self
    }

    pub(crate) fn block_unindent(mut self, config: &Config) -> Indent {
        if self.block_indent < config.tab_spaces() {
            Indent::new(self.block_indent, 0)
        } else {
            self.block_indent -= config.tab_spaces();
            self
        }
    }

    pub(crate) fn width(&self) -> usize {
        self.block_indent + self.alignment
    }

    pub(crate) fn to_string(&self, config: &Config) -> Cow<'static, str> {
        self.to_string_inner(config, 1)
    }

    pub(crate) fn to_string_with_newline(&self, config: &Config) -> Cow<'static, str> {
        self.to_string_inner(config, 0)
    }

    fn to_string_inner(&self, config: &Config, offset: usize) -> Cow<'static, str> {
        let (num_tabs, num_spaces) = if config.hard_tabs() {
            (self.block_indent / config.tab_spaces(), self.alignment)
        } else {
            (0, self.width())
        };
        let num_chars = num_tabs + num_spaces;
        if num_tabs == 0 && num_chars + offset <= INDENT_BUFFER_LEN {
            Cow::from(&INDENT_BUFFER[offset..=num_chars])
        } else {
            let mut indent = String::with_capacity(num_chars + if offset == 0 { 1 } else { 0 });
            if offset == 0 {
                indent.push('\n');
            }
            for _ in 0..num_tabs {
                indent.push('\t')
            }
            for _ in 0..num_spaces {
                indent.push(' ')
            }
            Cow::from(indent)
        }
    }
}

impl Add for Indent {
    type Output = Indent;

    fn add(self, rhs: Indent) -> Indent {
        Indent {
            block_indent: self.block_indent + rhs.block_indent,
            alignment: self.alignment + rhs.alignment,
        }
    }
}

impl Sub for Indent {
    type Output = Indent;

    fn sub(self, rhs: Indent) -> Indent {
        Indent::new(
            self.block_indent - rhs.block_indent,
            self.alignment - rhs.alignment,
        )
    }
}

impl Add<usize> for Indent {
    type Output = Indent;

    fn add(self, rhs: usize) -> Indent {
        Indent::new(self.block_indent, self.alignment + rhs)
    }
}

impl Sub<usize> for Indent {
    type Output = Indent;

    fn sub(self, rhs: usize) -> Indent {
        Indent::new(self.block_indent, self.alignment - rhs)
    }
}

// 8096 is close enough to infinite for rustfmt.
const INFINITE_SHAPE_WIDTH: usize = 8096;

#[derive(Copy, Clone, Debug)]
pub(crate) struct Shape {
    pub(crate) width: usize,
    // The current indentation of code.
    pub(crate) indent: Indent,
    // Indentation + any already emitted text on the first line of the current
    // statement.
    pub(crate) offset: usize,
}

impl Shape {
    /// `indent` is the indentation of the first line. The next lines
    /// should begin with at least `indent` spaces (except backwards
    /// indentation). The first line should not begin with indentation.
    /// `width` is the maximum number of characters on the last line
    /// (excluding `indent`). The width of other lines is not limited by
    /// `width`.
    /// Note that in reality, we sometimes use width for lines other than the
    /// last (i.e., we are conservative).
    // .......*-------*
    //        |       |
    //        |     *-*
    //        *-----|
    // |<------------>|  max width
    // |<---->|          indent
    //        |<--->|    width
    pub(crate) fn legacy(width: usize, indent: Indent) -> Shape {
        Shape {
            width,
            indent,
            offset: indent.alignment,
        }
    }

    pub(crate) fn indented(indent: Indent, config: &Config) -> Shape {
        Shape {
            width: config.max_width().saturating_sub(indent.width()),
            indent,
            offset: indent.alignment,
        }
    }

    pub(crate) fn with_max_width(&self, config: &Config) -> Shape {
        Shape {
            width: config.max_width().saturating_sub(self.indent.width()),
            ..*self
        }
    }

    pub(crate) fn visual_indent(&self, extra_width: usize) -> Shape {
        let alignment = self.offset + extra_width;
        Shape {
            width: self.width,
            indent: Indent::new(self.indent.block_indent, alignment),
            offset: alignment,
        }
    }

    pub(crate) fn block_indent(&self, extra_width: usize) -> Shape {
        if self.indent.alignment == 0 {
            Shape {
                width: self.width,
                indent: Indent::new(self.indent.block_indent + extra_width, 0),
                offset: 0,
            }
        } else {
            Shape {
                width: self.width,
                indent: self.indent + extra_width,
                offset: self.indent.alignment + extra_width,
            }
        }
    }

    pub(crate) fn block_left(&self, width: usize) -> Option<Shape> {
        self.block_indent(width).sub_width(width)
    }

    pub(crate) fn add_offset(&self, extra_width: usize) -> Shape {
        Shape {
            offset: self.offset + extra_width,
            ..*self
        }
    }

    pub(crate) fn block(&self) -> Shape {
        Shape {
            indent: self.indent.block_only(),
            ..*self
        }
    }

    pub(crate) fn saturating_sub_width(&self, width: usize) -> Shape {
        self.sub_width(width).unwrap_or(Shape { width: 0, ..*self })
    }

    pub(crate) fn sub_width(&self, width: usize) -> Option<Shape> {
        Some(Shape {
            width: self.width.checked_sub(width)?,
            ..*self
        })
    }

    pub(crate) fn shrink_left(&self, width: usize) -> Option<Shape> {
        Some(Shape {
            width: self.width.checked_sub(width)?,
            indent: self.indent + width,
            offset: self.offset + width,
        })
    }

    pub(crate) fn offset_left(&self, width: usize) -> Option<Shape> {
        self.add_offset(width).sub_width(width)
    }

    pub(crate) fn used_width(&self) -> usize {
        self.indent.block_indent + self.offset
    }

    pub(crate) fn rhs_overhead(&self, config: &Config) -> usize {
        config
            .max_width()
            .saturating_sub(self.used_width() + self.width)
    }

    pub(crate) fn comment(&self, config: &Config) -> Shape {
        let width = min(
            self.width,
            config.comment_width().saturating_sub(self.indent.width()),
        );
        Shape { width, ..*self }
    }

    pub(crate) fn to_string_with_newline(&self, config: &Config) -> Cow<'static, str> {
        let mut offset_indent = self.indent;
        offset_indent.alignment = self.offset;
        offset_indent.to_string_inner(config, 0)
    }

    /// Creates a `Shape` with a virtually infinite width.
    pub(crate) fn infinite_width(&self) -> Shape {
        Shape {
            width: INFINITE_SHAPE_WIDTH,
            ..*self
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn indent_add_sub() {
        let indent = Indent::new(4, 8) + Indent::new(8, 12);
        assert_eq!(12, indent.block_indent);
        assert_eq!(20, indent.alignment);

        let indent = indent - Indent::new(4, 4);
        assert_eq!(8, indent.block_indent);
        assert_eq!(16, indent.alignment);
    }

    #[test]
    fn indent_add_sub_alignment() {
        let indent = Indent::new(4, 8) + 4;
        assert_eq!(4, indent.block_indent);
        assert_eq!(12, indent.alignment);

        let indent = indent - 4;
        assert_eq!(4, indent.block_indent);
        assert_eq!(8, indent.alignment);
    }

    #[test]
    fn indent_to_string_spaces() {
        let config = Config::default();
        let indent = Indent::new(4, 8);

        // 12 spaces
        assert_eq!("            ", indent.to_string(&config));
    }

    #[test]
    fn indent_to_string_hard_tabs() {
        let mut config = Config::default();
        config.set().hard_tabs(true);
        let indent = Indent::new(8, 4);

        // 2 tabs + 4 spaces
        assert_eq!("\t\t    ", indent.to_string(&config));
    }

    #[test]
    fn shape_visual_indent() {
        let config = Config::default();
        let indent = Indent::new(4, 8);
        let shape = Shape::legacy(config.max_width(), indent);
        let shape = shape.visual_indent(20);

        assert_eq!(config.max_width(), shape.width);
        assert_eq!(4, shape.indent.block_indent);
        assert_eq!(28, shape.indent.alignment);
        assert_eq!(28, shape.offset);
    }

    #[test]
    fn shape_block_indent_without_alignment() {
        let config = Config::default();
        let indent = Indent::new(4, 0);
        let shape = Shape::legacy(config.max_width(), indent);
        let shape = shape.block_indent(20);

        assert_eq!(config.max_width(), shape.width);
        assert_eq!(24, shape.indent.block_indent);
        assert_eq!(0, shape.indent.alignment);
        assert_eq!(0, shape.offset);
    }

    #[test]
    fn shape_block_indent_with_alignment() {
        let config = Config::default();
        let indent = Indent::new(4, 8);
        let shape = Shape::legacy(config.max_width(), indent);
        let shape = shape.block_indent(20);

        assert_eq!(config.max_width(), shape.width);
        assert_eq!(4, shape.indent.block_indent);
        assert_eq!(28, shape.indent.alignment);
        assert_eq!(28, shape.offset);
    }
}
Commit	Line	Data
f20569fa XL	1	use std::borrow::Cow;
	2	use std::cmp::min;
	3	use std::ops::{Add, Sub};
	4
	5	use crate::Config;
	6
	7	#[derive(Copy, Clone, Debug)]
	8	pub(crate) struct Indent {
	9	// Width of the block indent, in characters. Must be a multiple of
	10	// Config::tab_spaces.
	11	pub(crate) block_indent: usize,
	12	// Alignment in characters.
	13	pub(crate) alignment: usize,
	14	}
	15
	16	// INDENT_BUFFER.len() = 81
	17	const INDENT_BUFFER_LEN: usize = 80;
	18	const INDENT_BUFFER: &str =
	19	"\n ";
	20
	21	impl Indent {
	22	pub(crate) fn new(block_indent: usize, alignment: usize) -> Indent {
	23	Indent {
	24	block_indent,
	25	alignment,
	26	}
	27	}
	28
	29	pub(crate) fn from_width(config: &Config, width: usize) -> Indent {
	30	if config.hard_tabs() {
	31	let tab_num = width / config.tab_spaces();
	32	let alignment = width % config.tab_spaces();
	33	Indent::new(config.tab_spaces() * tab_num, alignment)
	34	} else {
	35	Indent::new(width, 0)
	36	}
	37	}
	38
	39	pub(crate) fn empty() -> Indent {
	40	Indent::new(0, 0)
	41	}
	42
	43	pub(crate) fn block_only(&self) -> Indent {
	44	Indent {
	45	block_indent: self.block_indent,
	46	alignment: 0,
	47	}
	48	}
	49
	50	pub(crate) fn block_indent(mut self, config: &Config) -> Indent {
	51	self.block_indent += config.tab_spaces();
	52	self
	53	}
	54
	55	pub(crate) fn block_unindent(mut self, config: &Config) -> Indent {
	56	if self.block_indent < config.tab_spaces() {
	57	Indent::new(self.block_indent, 0)
	58	} else {
	59	self.block_indent -= config.tab_spaces();
	60	self
	61	}
	62	}
	63
	64	pub(crate) fn width(&self) -> usize {
65	self.block_indent + self.alignment
66	}
67
68	pub(crate) fn to_string(&self, config: &Config) -> Cow<'static, str> {
69	self.to_string_inner(config, 1)
70	}
71
72	pub(crate) fn to_string_with_newline(&self, config: &Config) -> Cow<'static, str> {
73	self.to_string_inner(config, 0)
74	}
75
76	fn to_string_inner(&self, config: &Config, offset: usize) -> Cow<'static, str> {
77	let (num_tabs, num_spaces) = if config.hard_tabs() {
78	(self.block_indent / config.tab_spaces(), self.alignment)
79	} else {
80	(0, self.width())
81	};
82	let num_chars = num_tabs + num_spaces;
83	if num_tabs == 0 && num_chars + offset <= INDENT_BUFFER_LEN {
84	Cow::from(&INDENT_BUFFER[offset..=num_chars])
85	} else {
86	let mut indent = String::with_capacity(num_chars + if offset == 0 { 1 } else { 0 });
87	if offset == 0 {
88	indent.push('\n');
89	}
90	for _ in 0..num_tabs {
91	indent.push('\t')
92	}
93	for _ in 0..num_spaces {
94	indent.push(' ')
95	}
96	Cow::from(indent)
97	}
98	}
99	}
100
101	impl Add for Indent {
102	type Output = Indent;
103
104	fn add(self, rhs: Indent) -> Indent {
105	Indent {
106	block_indent: self.block_indent + rhs.block_indent,
107	alignment: self.alignment + rhs.alignment,
108	}
109	}
110	}
111
112	impl Sub for Indent {
113	type Output = Indent;
114
115	fn sub(self, rhs: Indent) -> Indent {
116	Indent::new(
117	self.block_indent - rhs.block_indent,
118	self.alignment - rhs.alignment,
119	)
120	}
121	}
122
123	impl Add<usize> for Indent {
124	type Output = Indent;
125
126	fn add(self, rhs: usize) -> Indent {
127	Indent::new(self.block_indent, self.alignment + rhs)
128	}
129	}
130
131	impl Sub<usize> for Indent {
132	type Output = Indent;
133
134	fn sub(self, rhs: usize) -> Indent {
135	Indent::new(self.block_indent, self.alignment - rhs)
136	}
137	}
138
139	// 8096 is close enough to infinite for rustfmt.
140	const INFINITE_SHAPE_WIDTH: usize = 8096;
141
142	#[derive(Copy, Clone, Debug)]
143	pub(crate) struct Shape {
144	pub(crate) width: usize,
145	// The current indentation of code.
146	pub(crate) indent: Indent,
147	// Indentation + any already emitted text on the first line of the current
148	// statement.
149	pub(crate) offset: usize,
150	}
151
152	impl Shape {
153	/// `indent` is the indentation of the first line. The next lines
154	/// should begin with at least `indent` spaces (except backwards
155	/// indentation). The first line should not begin with indentation.
156	/// `width` is the maximum number of characters on the last line
157	/// (excluding `indent`). The width of other lines is not limited by
158	/// `width`.
159	/// Note that in reality, we sometimes use width for lines other than the
160	/// last (i.e., we are conservative).
161	// .......-------
162	// \| \|
163	// \| -
164	// *-----\|
165	// \|<------------>\| max width
166	// \|<---->\| indent
167	// \|<--->\| width
168	pub(crate) fn legacy(width: usize, indent: Indent) -> Shape {
169	Shape {
170	width,
171	indent,
172	offset: indent.alignment,
173	}
174	}
175
176	pub(crate) fn indented(indent: Indent, config: &Config) -> Shape {
177	Shape {
178	width: config.max_width().saturating_sub(indent.width()),
179	indent,
180	offset: indent.alignment,
181	}
182	}
183
184	pub(crate) fn with_max_width(&self, config: &Config) -> Shape {
185	Shape {
186	width: config.max_width().saturating_sub(self.indent.width()),
187	..*self
188	}
189	}
190
191	pub(crate) fn visual_indent(&self, extra_width: usize) -> Shape {
192	let alignment = self.offset + extra_width;
193	Shape {
194	width: self.width,
195	indent: Indent::new(self.indent.block_indent, alignment),
196	offset: alignment,
197	}
198	}
199
200	pub(crate) fn block_indent(&self, extra_width: usize) -> Shape {
201	if self.indent.alignment == 0 {
202	Shape {
203	width: self.width,
204	indent: Indent::new(self.indent.block_indent + extra_width, 0),
205	offset: 0,
206	}
207	} else {
208	Shape {
209	width: self.width,
210	indent: self.indent + extra_width,
211	offset: self.indent.alignment + extra_width,
212	}
213	}
214	}
215
216	pub(crate) fn block_left(&self, width: usize) -> Option<Shape> {
217	self.block_indent(width).sub_width(width)
218	}
219
220	pub(crate) fn add_offset(&self, extra_width: usize) -> Shape {
221	Shape {
222	offset: self.offset + extra_width,
223	..*self
224	}
225	}
226
227	pub(crate) fn block(&self) -> Shape {
228	Shape {
229	indent: self.indent.block_only(),
230	..*self
231	}
232	}
233
234	pub(crate) fn saturating_sub_width(&self, width: usize) -> Shape {
235	self.sub_width(width).unwrap_or(Shape { width: 0, ..*self })
236	}
237
238	pub(crate) fn sub_width(&self, width: usize) -> Option<Shape> {
239	Some(Shape {
240	width: self.width.checked_sub(width)?,
241	..*self
242	})
243	}
244
245	pub(crate) fn shrink_left(&self, width: usize) -> Option<Shape> {
246	Some(Shape {
247	width: self.width.checked_sub(width)?,
248	indent: self.indent + width,
249	offset: self.offset + width,
250	})
251	}
252
253	pub(crate) fn offset_left(&self, width: usize) -> Option<Shape> {
254	self.add_offset(width).sub_width(width)
255	}
256
257	pub(crate) fn used_width(&self) -> usize {
258	self.indent.block_indent + self.offset
259	}
260
261	pub(crate) fn rhs_overhead(&self, config: &Config) -> usize {
262	config
263	.max_width()
264	.saturating_sub(self.used_width() + self.width)
265	}
266
267	pub(crate) fn comment(&self, config: &Config) -> Shape {
268	let width = min(
269	self.width,
270	config.comment_width().saturating_sub(self.indent.width()),
271	);
272	Shape { width, ..*self }
273	}
274
275	pub(crate) fn to_string_with_newline(&self, config: &Config) -> Cow<'static, str> {
276	let mut offset_indent = self.indent;
277	offset_indent.alignment = self.offset;
278	offset_indent.to_string_inner(config, 0)
279	}
280
281	/// Creates a `Shape` with a virtually infinite width.
282	pub(crate) fn infinite_width(&self) -> Shape {
283	Shape {
284	width: INFINITE_SHAPE_WIDTH,
285	..*self
286	}
287	}
288	}
289
290	#[cfg(test)]
291	mod test {
292	use super::*;
293
294	#[test]
295	fn indent_add_sub() {
296	let indent = Indent::new(4, 8) + Indent::new(8, 12);
297	assert_eq!(12, indent.block_indent);
298	assert_eq!(20, indent.alignment);
299
300	let indent = indent - Indent::new(4, 4);
301	assert_eq!(8, indent.block_indent);
302	assert_eq!(16, indent.alignment);
303	}
304
305	#[test]
306	fn indent_add_sub_alignment() {
307	let indent = Indent::new(4, 8) + 4;
308	assert_eq!(4, indent.block_indent);
309	assert_eq!(12, indent.alignment);
310
311	let indent = indent - 4;
312	assert_eq!(4, indent.block_indent);
313	assert_eq!(8, indent.alignment);
314	}
315
316	#[test]
317	fn indent_to_string_spaces() {
318	let config = Config::default();
319	let indent = Indent::new(4, 8);
320
321	// 12 spaces
322	assert_eq!(" ", indent.to_string(&config));
323	}
324
325	#[test]
326	fn indent_to_string_hard_tabs() {
327	let mut config = Config::default();
328	config.set().hard_tabs(true);
329	let indent = Indent::new(8, 4);
330
331	// 2 tabs + 4 spaces
332	assert_eq!("\t\t ", indent.to_string(&config));
333	}
334
335	#[test]
336	fn shape_visual_indent() {
337	let config = Config::default();
338	let indent = Indent::new(4, 8);
339	let shape = Shape::legacy(config.max_width(), indent);
340	let shape = shape.visual_indent(20);
341
342	assert_eq!(config.max_width(), shape.width);
343	assert_eq!(4, shape.indent.block_indent);
344	assert_eq!(28, shape.indent.alignment);
345	assert_eq!(28, shape.offset);
346	}
347
348	#[test]
349	fn shape_block_indent_without_alignment() {
350	let config = Config::default();
351	let indent = Indent::new(4, 0);
352	let shape = Shape::legacy(config.max_width(), indent);
353	let shape = shape.block_indent(20);
354
355	assert_eq!(config.max_width(), shape.width);
356	assert_eq!(24, shape.indent.block_indent);
357	assert_eq!(0, shape.indent.alignment);
358	assert_eq!(0, shape.offset);
359	}
360
361	#[test]
362	fn shape_block_indent_with_alignment() {
363	let config = Config::default();
364	let indent = Indent::new(4, 8);
365	let shape = Shape::legacy(config.max_width(), indent);
366	let shape = shape.block_indent(20);
367
368	assert_eq!(config.max_width(), shape.width);
369	assert_eq!(4, shape.indent.block_indent);
370	assert_eq!(28, shape.indent.alignment);
371	assert_eq!(28, shape.offset);
372	}
373	}