Skip to content

Commit 167e95e

Browse files
ablommablomm
committed
Ignore error messages associated with Error type
1 parent 636fabf commit 167e95e

15 files changed

Lines changed: 107 additions & 261 deletions

File tree

‎assembler/clippy.toml‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1 @@
1+
large-error-threshold = 256 # TODO: pass error in Box<T>

‎assembler/src/error.rs‎

Lines changed: 24 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
use std::{fmt::Display, io::Write};
22

3-
use crate::{Span, src::Src};
3+
use crate::{Span, expression::expression_result::ExpressionResult, span::Spanned, src::Src};
44
use ariadne::{Cache, Color, Fmt};
55
use chumsky::error::{RichPattern, RichReason};
66
use internment::Intern;
@@ -23,6 +23,11 @@ pub struct SpannedError {
2323
labels: Vec<(Span, String)>,
2424
notes: Vec<String>,
2525
helps: Vec<String>,
26+
27+
// if we should not print this error
28+
// useful if this error is a consequence of a previous error that should already be printed, so
29+
// printing this one would just increase noise
30+
ignored: bool,
2631
}
2732

2833
impl SpannedError {
@@ -33,6 +38,7 @@ impl SpannedError {
3338
labels: Vec::new(),
3439
notes: Vec::new(),
3540
helps: Vec::new(),
41+
ignored: false,
3642
}
3743
}
3844

@@ -58,6 +64,11 @@ impl SpannedError {
5864
self
5965
}
6066

67+
pub fn ignored(mut self, ignored: bool) -> Self {
68+
self.ignored = ignored;
69+
self
70+
}
71+
6172
// check if any of the spans in this error intersect the given span
6273
pub fn any_span_intersect(&self, span: Span) -> bool {
6374
span.intersects(&self.span)
@@ -74,6 +85,10 @@ impl SpannedError {
7485
) -> Result<(), std::io::Error> {
7586
use ariadne::{Config, IndexType, Label, Report, ReportKind};
7687

88+
if self.ignored {
89+
return Ok(());
90+
}
91+
7792
let labels = self.labels.iter().map(|(span, message)| {
7893
Label::new(*span)
7994
.with_message(message)
@@ -131,6 +146,14 @@ impl SpannedError {
131146
))
132147
}
133148

149+
pub fn incorrect_type(expected: Vec<impl Display>, found: &Spanned<&ExpressionResult>) -> Self {
150+
// Error type is ignored because there should already be an error for when that result was
151+
// created; no need to print any more errors about it
152+
let ignored = matches!(found.val, ExpressionResult::Error);
153+
154+
Self::incorrect_value(found.span, "type", expected, Some(found.val)).ignored(ignored)
155+
}
156+
134157
pub fn incorrect_value(
135158
span: Span,
136159
object_name: impl Display,

‎assembler/src/expression/expression_result.rs‎

Lines changed: 21 additions & 84 deletions
Original file line numberDiff line numberDiff line change
@@ -88,7 +88,7 @@ impl Display for ExpressionResult {
8888
ExpressionResult::Register(_) => "register",
8989
ExpressionResult::RegisterOffset(_) => "register offset",
9090
ExpressionResult::Indirect(indirect) => &format!("{} {}", "indirect", **indirect),
91-
ExpressionResult::Error => "unknown (previous error)",
91+
ExpressionResult::Error => "unknown (from previous error)",
9292
};
9393

9494
write!(f, "{}", string)
@@ -129,15 +129,11 @@ impl AsmRef for &Spanned<&ExpressionResult> {
129129
fn asm_ref(self) -> Self::Output {
130130
match self.val {
131131
ExpressionResult::Indirect(indirect) => self.span_to(indirect).asm_ref(),
132-
_ => Err(SpannedError::incorrect_value(
133-
self.span,
134-
"type",
135-
vec!["indirect"],
136-
Some(self.val),
137-
)
138-
.with_note(
139-
"You can only take a reference of a value that was previously dereferenced",
140-
)),
132+
_ => Err(
133+
SpannedError::incorrect_type(vec!["indirect"], self).with_note(
134+
"You can only take a reference of a value that was previously dereferenced",
135+
),
136+
),
141137
}
142138
}
143139
}
@@ -157,12 +153,7 @@ impl Neg for &Spanned<&ExpressionResult> {
157153
fn neg(self) -> Self::Output {
158154
match self.val {
159155
ExpressionResult::Number(number) => -&self.span_to(number),
160-
_ => Err(SpannedError::incorrect_value(
161-
self.span,
162-
"type",
163-
vec!["number"],
164-
Some(self.val),
165-
)),
156+
_ => Err(SpannedError::incorrect_type(vec!["number"], self)),
166157
}
167158
}
168159
}
@@ -172,12 +163,7 @@ impl Not for &Spanned<&ExpressionResult> {
172163
fn not(self) -> Self::Output {
173164
match self.val {
174165
ExpressionResult::Number(number) => !&self.span_to(number),
175-
_ => Err(SpannedError::incorrect_value(
176-
self.span,
177-
"type",
178-
vec!["number"],
179-
Some(self.val),
180-
)),
166+
_ => Err(SpannedError::incorrect_type(vec!["number"], self)),
181167
}
182168
}
183169
}
@@ -187,12 +173,7 @@ impl Mul<&Spanned<&ExpressionResult>> for &Spanned<&ExpressionResult> {
187173
fn mul(self, rhs: &Spanned<&ExpressionResult>) -> Self::Output {
188174
match self.val {
189175
ExpressionResult::Number(number) => &self.span_to(number) * rhs,
190-
_ => Err(SpannedError::incorrect_value(
191-
self.span,
192-
"type",
193-
vec!["number"],
194-
Some(self.val),
195-
)),
176+
_ => Err(SpannedError::incorrect_type(vec!["number"], self)),
196177
}
197178
}
198179
}
@@ -202,12 +183,7 @@ impl Div<&Spanned<&ExpressionResult>> for &Spanned<&ExpressionResult> {
202183
fn div(self, rhs: &Spanned<&ExpressionResult>) -> Self::Output {
203184
match self.val {
204185
ExpressionResult::Number(number) => &self.span_to(number) / rhs,
205-
_ => Err(SpannedError::incorrect_value(
206-
self.span,
207-
"type",
208-
vec!["number"],
209-
Some(self.val),
210-
)),
186+
_ => Err(SpannedError::incorrect_type(vec!["number"], self)),
211187
}
212188
}
213189
}
@@ -217,12 +193,7 @@ impl Rem<&Spanned<&ExpressionResult>> for &Spanned<&ExpressionResult> {
217193
fn rem(self, rhs: &Spanned<&ExpressionResult>) -> Self::Output {
218194
match self.val {
219195
ExpressionResult::Number(number) => &self.span_to(number) % rhs,
220-
_ => Err(SpannedError::incorrect_value(
221-
self.span,
222-
"type",
223-
vec!["number"],
224-
Some(self.val),
225-
)),
196+
_ => Err(SpannedError::incorrect_type(vec!["number"], self)),
226197
}
227198
}
228199
}
@@ -235,11 +206,9 @@ impl Add<&Spanned<&ExpressionResult>> for &Spanned<&ExpressionResult> {
235206
ExpressionResult::String(string) => &self.span_to(string) + rhs,
236207
ExpressionResult::Register(register) => &self.span_to(register) + rhs,
237208
ExpressionResult::RegisterOffset(reg_offset) => &self.span_to(reg_offset) + rhs,
238-
_ => Err(SpannedError::incorrect_value(
239-
self.span,
240-
"type",
209+
_ => Err(SpannedError::incorrect_type(
241210
vec!["number", "string", "register", "register offset"],
242-
Some(self.val),
211+
self,
243212
)),
244213
}
245214
}
@@ -252,11 +221,9 @@ impl Sub<&Spanned<&ExpressionResult>> for &Spanned<&ExpressionResult> {
252221
ExpressionResult::Number(number) => &self.span_to(number) - rhs,
253222
ExpressionResult::Register(register) => &self.span_to(register) - rhs,
254223
ExpressionResult::RegisterOffset(reg_offset) => &self.span_to(reg_offset) - rhs,
255-
_ => Err(SpannedError::incorrect_value(
256-
self.span,
257-
"type",
224+
_ => Err(SpannedError::incorrect_type(
258225
vec!["number", "register", "register offset"],
259-
Some(self.val),
226+
self,
260227
)),
261228
}
262229
}
@@ -267,12 +234,7 @@ impl Shl<&Spanned<&ExpressionResult>> for &Spanned<&ExpressionResult> {
267234
fn shl(self, rhs: &Spanned<&ExpressionResult>) -> Self::Output {
268235
match self.val {
269236
ExpressionResult::Number(number) => &self.span_to(number) << rhs,
270-
_ => Err(SpannedError::incorrect_value(
271-
self.span,
272-
"type",
273-
vec!["number"],
274-
Some(self.val),
275-
)),
237+
_ => Err(SpannedError::incorrect_type(vec!["number"], self)),
276238
}
277239
}
278240
}
@@ -282,12 +244,7 @@ impl Shr<&Spanned<&ExpressionResult>> for &Spanned<&ExpressionResult> {
282244
fn shr(self, rhs: &Spanned<&ExpressionResult>) -> Self::Output {
283245
match self.val {
284246
ExpressionResult::Number(number) => &self.span_to(number) >> rhs,
285-
_ => Err(SpannedError::incorrect_value(
286-
self.span,
287-
"type",
288-
vec!["number"],
289-
Some(self.val),
290-
)),
247+
_ => Err(SpannedError::incorrect_type(vec!["number"], self)),
291248
}
292249
}
293250
}
@@ -297,12 +254,7 @@ impl Ashr<&Spanned<&ExpressionResult>> for &Spanned<&ExpressionResult> {
297254
fn ashr(self, rhs: &Spanned<&ExpressionResult>) -> Self::Output {
298255
match self.val {
299256
ExpressionResult::Number(number) => self.span_to(number).ashr(rhs),
300-
_ => Err(SpannedError::incorrect_value(
301-
self.span,
302-
"type",
303-
vec!["number"],
304-
Some(self.val),
305-
)),
257+
_ => Err(SpannedError::incorrect_type(vec!["number"], self)),
306258
}
307259
}
308260
}
@@ -312,12 +264,7 @@ impl BitAnd<&Spanned<&ExpressionResult>> for &Spanned<&ExpressionResult> {
312264
fn bitand(self, rhs: &Spanned<&ExpressionResult>) -> Self::Output {
313265
match self.val {
314266
ExpressionResult::Number(number) => &self.span_to(number) & rhs,
315-
_ => Err(SpannedError::incorrect_value(
316-
self.span,
317-
"type",
318-
vec!["number"],
319-
Some(self.val),
320-
)),
267+
_ => Err(SpannedError::incorrect_type(vec!["number"], self)),
321268
}
322269
}
323270
}
@@ -327,12 +274,7 @@ impl BitOr<&Spanned<&ExpressionResult>> for &Spanned<&ExpressionResult> {
327274
fn bitor(self, rhs: &Spanned<&ExpressionResult>) -> Self::Output {
328275
match self.val {
329276
ExpressionResult::Number(number) => &self.span_to(number) | rhs,
330-
_ => Err(SpannedError::incorrect_value(
331-
self.span,
332-
"type",
333-
vec!["number"],
334-
Some(self.val),
335-
)),
277+
_ => Err(SpannedError::incorrect_type(vec!["number"], self)),
336278
}
337279
}
338280
}
@@ -342,12 +284,7 @@ impl BitXor<&Spanned<&ExpressionResult>> for &Spanned<&ExpressionResult> {
342284
fn bitxor(self, rhs: &Spanned<&ExpressionResult>) -> Self::Output {
343285
match self.val {
344286
ExpressionResult::Number(number) => &self.span_to(number) ^ rhs,
345-
_ => Err(SpannedError::incorrect_value(
346-
self.span,
347-
"type",
348-
vec!["number"],
349-
Some(self.val),
350-
)),
287+
_ => Err(SpannedError::incorrect_type(vec!["number"], self)),
351288
}
352289
}
353290
}

0 commit comments

Comments
 (0)