15426399429

Committed 03 Jun 2025 07:45PM UTC coverage: 74.032% (+1.1%) from 72.943%

Build # 15426399429

Build Type

push

github

Committed by

TyRoXx

Commit Message

GH-275: begin code formatting algorithm

Run Details

217 of 219 new or added lines in 2 files covered. (99.09%)

3 existing lines in 1 file now uncovered.

3689 of 4983 relevant lines covered (74.03%)

2080.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.67

/lambda_compiler/src/format.rs

use crate::ast::{Expression, LambdaParameter};

fn format_string_literal<W>(content: &str, writer: &mut W) -> std::fmt::Result
where
    W: std::fmt::Write,
{
    write!(writer, "\"")?;
    for character in content.chars() {
        match character {
            '"' | '\'' | '\\' => write!(writer, "\\{character}")?,
            '\n' => write!(writer, "\\n")?,
            '\r' => write!(writer, "\\r")?,
            '\t' => write!(writer, "\\t")?,
            _ => write!(writer, "{character}")?,
        }
    }
    write!(writer, "\"")
}

fn format_apply<W>(
    callee: &Expression,
    arguments: &[Expression],
    indentation_level: usize,
    writer: &mut W,
) -> std::fmt::Result
where
    W: std::fmt::Write,
{
    format_expression(callee, indentation_level, writer)?;
    write!(writer, "(")?;
    for argument in arguments.iter() {
        format_expression(argument, indentation_level, writer)?;
        write!(writer, ", ")?;
    }
    write!(writer, ")")
}

fn format_lambda<W>(
    parameters: &[LambdaParameter],
    body: &Expression,
    indentation_level: usize,
    writer: &mut W,
) -> std::fmt::Result
where
    W: std::fmt::Write,
{
    write!(writer, "(")?;
    for parameter in parameters.iter() {
        write!(writer, "{}", parameter.name.key)?;
        if let Some(type_annotation) = &parameter.type_annotation {
            write!(writer, ": ")?;
            format_expression(type_annotation, indentation_level, writer)?;
        }
        write!(writer, ", ")?;
    }
    write!(writer, ") => ")?;
    format_expression(body, indentation_level + 1, writer)
}

fn break_line<W>(indentation_level: usize, writer: &mut W) -> std::fmt::Result
where
    W: std::fmt::Write,
{
    writeln!(writer)?;
    for _ in 0..indentation_level {
        write!(writer, "    ")?;
    }
    Ok(())
}

pub fn format_expression<W>(
    expression: &Expression,
    indentation_level: usize,
    writer: &mut W,
) -> std::fmt::Result
where
    W: std::fmt::Write,
{
    match expression {
        Expression::Identifier(name, _source_location) => write!(writer, "{}", &name.key),
        Expression::StringLiteral(content) => format_string_literal(content, writer),
        Expression::Apply { callee, arguments } => {
            format_apply(callee, arguments, indentation_level, writer)
        }
        Expression::Lambda { parameters, body } => {
            format_lambda(parameters, body, indentation_level, writer)
        }
        Expression::ConstructTree(children) => {
            write!(writer, "[")?;
            for child in children.iter() {
                format_expression(child, indentation_level, writer)?;
                write!(writer, ", ")?;
            }
            write!(writer, "]")
        }
        Expression::Braces(expression) => {
            write!(writer, "{{")?;
            format_expression(expression, indentation_level, writer)?;
            write!(writer, "}}")
        }
        Expression::Let {
            name,
            location: _,
            value,
            body,
        } => {
            write!(writer, "let {} = ", &name.key)?;
            format_expression(value, indentation_level, writer)?;
            break_line(indentation_level, writer)?;
            format_expression(body, indentation_level, writer)
        }
    }
}

1	use crate::ast::{Expression, LambdaParameter};
2
3	fn format_string_literal<W>(content: &str, writer: &mut W) -> std::fmt::Result	6✔
4	where
5	W: std::fmt::Write,
6	{
7	write!(writer, "\"")?;	6✔
8	for character in content.chars() {	29✔
9	match character {	23✔
10	'"' \| '\'' \| '\\' => write!(writer, "\\{character}")?,	3✔
11	'\n' => write!(writer, "\\n")?,	1✔
12	'\r' => write!(writer, "\\r")?,	1✔
13	'\t' => write!(writer, "\\t")?,	1✔
14	_ => write!(writer, "{character}")?,	17✔
15	}
16	}
17	write!(writer, "\"")	6✔
18	}
19
20	fn format_apply<W>(	3✔
21	callee: &Expression,
22	arguments: &[Expression],
23	indentation_level: usize,
24	writer: &mut W,
25	) -> std::fmt::Result
26	where
27	W: std::fmt::Write,
28	{
29	format_expression(callee, indentation_level, writer)?;	3✔
30	write!(writer, "(")?;	3✔
31	for argument in arguments.iter() {	6✔
32	format_expression(argument, indentation_level, writer)?;	3✔
33	write!(writer, ", ")?;	3✔
34	}
35	write!(writer, ")")	3✔
36	}
37
38	fn format_lambda<W>(	5✔
39	parameters: &[LambdaParameter],
40	body: &Expression,
41	indentation_level: usize,
42	writer: &mut W,
43	) -> std::fmt::Result
44	where
45	W: std::fmt::Write,
46	{
47	write!(writer, "(")?;	5✔
48	for parameter in parameters.iter() {	9✔
49	write!(writer, "{}", parameter.name.key)?;	4✔
50	if let Some(type_annotation) = &parameter.type_annotation {	5✔
NEW 51	write!(writer, ": ")?;	×
52	format_expression(type_annotation, indentation_level, writer)?;	1✔
53	}
54	write!(writer, ", ")?;	4✔
55	}
56	write!(writer, ") => ")?;	5✔
57	format_expression(body, indentation_level + 1, writer)	5✔
58	}
59
60	fn break_line<W>(indentation_level: usize, writer: &mut W) -> std::fmt::Result	2✔
61	where
62	W: std::fmt::Write,
63	{
64	writeln!(writer)?;	2✔
65	for _ in 0..indentation_level {	2✔
66	write!(writer, " ")?;	1✔
67	}
68	Ok(())	2✔
69	}
70
71	pub fn format_expression<W>(	37✔
72	expression: &Expression,
73	indentation_level: usize,
74	writer: &mut W,
75	) -> std::fmt::Result
76	where
77	W: std::fmt::Write,
78	{
79	match expression {	37✔
80	Expression::Identifier(name, _source_location) => write!(writer, "{}", &name.key),	17✔
81	Expression::StringLiteral(content) => format_string_literal(content, writer),	6✔
82	Expression::Apply { callee, arguments } => {	3✔
83	format_apply(callee, arguments, indentation_level, writer)	3✔
84	}
85	Expression::Lambda { parameters, body } => {	5✔
86	format_lambda(parameters, body, indentation_level, writer)	5✔
87	}
88	Expression::ConstructTree(children) => {	3✔
89	write!(writer, "[")?;	3✔
90	for child in children.iter() {	6✔
91	format_expression(child, indentation_level, writer)?;	3✔
92	write!(writer, ", ")?;	3✔
93	}
94	write!(writer, "]")	3✔
95	}
96	Expression::Braces(expression) => {	1✔
97	write!(writer, "{{")?;	1✔
98	format_expression(expression, indentation_level, writer)?;	1✔
99	write!(writer, "}}")	1✔
100	}
NEW 101	Expression::Let {	×
102	name,	2✔
103	location: _,	2✔
104	value,	2✔
105	body,	2✔
106	} => {	2✔
107	write!(writer, "let {} = ", &name.key)?;	2✔
108	format_expression(value, indentation_level, writer)?;	2✔
109	break_line(indentation_level, writer)?;	2✔
110	format_expression(body, indentation_level, writer)	2✔
111	}
112	}
113	}

TyRoXx / NonlocalityOS / 15426399429

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous