15650805231

Committed 14 Jun 2025 09:49AM UTC coverage: 76.604% (+0.3%) from 76.336%

Build # 15650805231

Build Type

Pull #293

github

Committed by

web-flow

Commit Message

Merge 7c8143176 into b9c75376a

Pull Request Pull Request #293: GH-292: Integers

Run Details

77 of 95 new or added lines in 8 files covered. (81.05%)

6 existing lines in 2 files now uncovered.

4142 of 5407 relevant lines covered (76.6%)

2239.66 hits per line

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

96.51

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

TyRoXx / NonlocalityOS / 15650805231

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