17578334644

Committed 09 Sep 2025 09:34AM UTC coverage: 76.581% (-0.3%) from 76.862%

Build # 17578334644

Build Type

push

github

Committed by

TyRoXx

Commit Message

Fix new clippy warnings

Run Details

14 of 18 new or added lines in 4 files covered. (77.78%)

65 existing lines in 10 files now uncovered.

3852 of 5030 relevant lines covered (76.58%)

4265.49 hits per line

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

93.02

/lambda_compiler/src/format.rs

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

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 (index, argument) in arguments.iter().enumerate() {
        if index > 0 {
            write!(writer, ", ")?;
        }
        format_expression(argument, indentation_level, 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 (index, parameter) in parameters.iter().enumerate() {
        if index > 0 {
            write!(writer, ", ")?;
        }
        write!(writer, "{}", parameter.name.key)?;
        if let Some(type_annotation) = &parameter.type_annotation {
            write!(writer, ": ")?;
            format_expression(type_annotation, indentation_level, writer)?;
        }
    }
    write!(writer, ") => ")?;
    format_expression(body, indentation_level, 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_braces<W>(
    content: &Expression,
    indentation_level: usize,
    writer: &mut W,
) -> std::fmt::Result
where
    W: std::fmt::Write,
{
    write!(writer, "{{")?;
    let mut content_formatted = String::new();
    format_expression(content, indentation_level, &mut content_formatted)?;
    if content_formatted.contains('\n') {
        let inner_indentation_level = indentation_level + 1;
        break_line(inner_indentation_level, writer)?;
        format_expression(content, inner_indentation_level, writer)?;
        break_line(indentation_level, writer)?;
    } else {
        write!(writer, "{content_formatted}")?;
    }
    write!(writer, "}}")
}

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, _source_location) => {
            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 (index, child) in children.iter().enumerate() {
                if index > 0 {
                    write!(writer, ", ")?;
                }
                format_expression(child, indentation_level, writer)?;
            }
            write!(writer, "]")
        }
        Expression::Braces(content) => format_braces(content, indentation_level, 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)
        }
        Expression::TypeOf(expression) => {
            write!(writer, "type_of(")?;
            format_expression(expression, indentation_level, writer)?;
            write!(writer, ")")
        }
        Expression::Comment(comment, expression, _source_location) => {
            write!(writer, "#{comment}")?;
            break_line(indentation_level, writer)?;
            format_expression(expression, indentation_level, writer)
        }
        Expression::IntegerLiteral(value, base, _source_location) => match base {
            IntegerBase::Decimal => write!(writer, "{value}"),
            IntegerBase::Hexadecimal => write!(writer, "0x{value:x}"),
        },
    }
}

pub fn format_file<W>(entry_point: &Expression, writer: &mut W) -> std::fmt::Result
where
    W: std::fmt::Write,
{
    format_expression(entry_point, 0, writer)?;
    writeln!(writer)
}

1	use crate::{
2	ast::{Expression, LambdaParameter},
3	tokenization::IntegerBase,
4	};
5
6	fn format_string_literal<W>(content: &str, writer: &mut W) -> std::fmt::Result	23✔
7	where
8	W: std::fmt::Write,
9	{
10	write!(writer, "\"")?;	69✔
11	for character in content.chars() {	95✔
12	match character {	72✔
13	'"' \| '\'' \| '\\' => write!(writer, "\\{character}")?,	3✔
14	'\n' => write!(writer, "\\n")?,	3✔
15	'\r' => write!(writer, "\\r")?,	3✔
16	'\t' => write!(writer, "\\t")?,	3✔
17	_ => write!(writer, "{character}")?,	198✔
18	}
19	}
20	write!(writer, "\"")	23✔
21	}
22
23	fn format_apply<W>(	16✔
24	callee: &Expression,
25	arguments: &[Expression],
26	indentation_level: usize,
27	writer: &mut W,
28	) -> std::fmt::Result
29	where
30	W: std::fmt::Write,
31	{
32	format_expression(callee, indentation_level, writer)?;	64✔
33	write!(writer, "(")?;	16✔
34	for (index, argument) in arguments.iter().enumerate() {	66✔
35	if index > 0 {	25✔
36	write!(writer, ", ")?;	33✔
37	}
38	format_expression(argument, indentation_level, writer)?;	25✔
39	}
40	write!(writer, ")")	16✔
41	}
42
43	fn format_lambda<W>(	25✔
44	parameters: &[LambdaParameter],
45	body: &Expression,
46	indentation_level: usize,
47	writer: &mut W,
48	) -> std::fmt::Result
49	where
50	W: std::fmt::Write,
51	{
52	write!(writer, "(")?;	75✔
53	for (index, parameter) in parameters.iter().enumerate() {	77✔
54	if index > 0 {	26✔
55	write!(writer, ", ")?;	33✔
56	}
57	write!(writer, "{}", parameter.name.key)?;	26✔
58	if let Some(type_annotation) = &parameter.type_annotation {	47✔
59	write!(writer, ": ")?;	×
60	format_expression(type_annotation, indentation_level, writer)?;	21✔
61	}
62	}
63	write!(writer, ") => ")?;	25✔
64	format_expression(body, indentation_level, writer)	25✔
65	}
66
67	fn break_line<W>(indentation_level: usize, writer: &mut W) -> std::fmt::Result	71✔
68	where
69	W: std::fmt::Write,
70	{
71	writeln!(writer)?;	142✔
72	for _ in 0..indentation_level {	71✔
73	write!(writer, " ")?;	138✔
74	}
75	Ok(())	71✔
76	}
77
78	pub fn format_braces<W>(	14✔
79	content: &Expression,
80	indentation_level: usize,
81	writer: &mut W,
82	) -> std::fmt::Result
83	where
84	W: std::fmt::Write,
85	{
86	write!(writer, "{{")?;	42✔
87	let mut content_formatted = String::new();	14✔
UNCOV 88	format_expression(content, indentation_level, &mut content_formatted)?;	×
89	if content_formatted.contains('\n') {	14✔
90	let inner_indentation_level = indentation_level + 1;	18✔
91	break_line(inner_indentation_level, writer)?;	27✔
92	format_expression(content, inner_indentation_level, writer)?;	9✔
93	break_line(indentation_level, writer)?;	9✔
94	} else {
95	write!(writer, "{content_formatted}")?;	5✔
96	}
97	write!(writer, "}}")	14✔
98	}
99
100	pub fn format_expression<W>(	275✔
101	expression: &Expression,
102	indentation_level: usize,
103	writer: &mut W,
104	) -> std::fmt::Result
105	where
106	W: std::fmt::Write,
107	{
108	match expression {	275✔
109	Expression::Identifier(name, _source_location) => write!(writer, "{}", &name.key),	113✔
110	Expression::StringLiteral(content, _source_location) => {	46✔
111	format_string_literal(content, writer)	69✔
112	}
113	Expression::Apply { callee, arguments } => {	32✔
114	format_apply(callee, arguments, indentation_level, writer)	80✔
115	}
116	Expression::Lambda { parameters, body } => {	50✔
117	format_lambda(parameters, body, indentation_level, writer)	125✔
118	}
119	Expression::ConstructTree(children, _) => {	16✔
120	write!(writer, "[")?;	48✔
121	for (index, child) in children.iter().enumerate() {	76✔
122	if index > 0 {	30✔
123	write!(writer, ", ")?;	45✔
124	}
125	format_expression(child, indentation_level, writer)?;	30✔
126	}
127	write!(writer, "]")	16✔
128	}
129	Expression::Braces(content) => format_braces(content, indentation_level, writer),	70✔
130	Expression::Let {	×
131	name,	46✔
UNCOV 132	location: _,	×
133	value,	46✔
134	body,	46✔
UNCOV 135	} => {	×
136	write!(writer, "let {} = ", &name.key)?;	184✔
137	format_expression(value, indentation_level, writer)?;	46✔
138	break_line(indentation_level, writer)?;	46✔
139	format_expression(body, indentation_level, writer)	46✔
140	}
141	Expression::TypeOf(expression) => {	9✔
142	write!(writer, "type_of(")?;	27✔
143	format_expression(expression, indentation_level, writer)?;	9✔
144	write!(writer, ")")	9✔
145	}
146	Expression::Comment(comment, expression, _source_location) => {	21✔
147	write!(writer, "#{comment}")?;	21✔
148	break_line(indentation_level, writer)?;	7✔
149	format_expression(expression, indentation_level, writer)	7✔
150	}
151	Expression::IntegerLiteral(value, base, _source_location) => match base {	24✔
152	IntegerBase::Decimal => write!(writer, "{value}"),	6✔
153	IntegerBase::Hexadecimal => write!(writer, "0x{value:x}"),	×
154	},
155	}
156	}
157
158	pub fn format_file<W>(entry_point: &Expression, writer: &mut W) -> std::fmt::Result	6✔
159	where
160	W: std::fmt::Write,
161	{
162	format_expression(entry_point, 0, writer)?;	18✔
163	writeln!(writer)	6✔
164	}

TyRoXx / NonlocalityOS / 17578334644

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