1use crate::ast::*;
3use crate::formatter::IntoFormatter;
4use crate::pretty::FmtWithCtx;
5pub use annotate_snippets::Level;
6use itertools::Itertools;
7use macros::VariantIndexArity;
8use petgraph::algo::dijkstra::dijkstra;
9use petgraph::prelude::DiGraphMap;
10use std::cmp::{Ord, PartialOrd};
11use std::collections::{HashMap, HashSet};
12
13#[macro_export]
14macro_rules! register_error {
15 ($ctx:expr, crate($krate:expr), $span: expr, $($fmt:tt)*) => {{
16 let msg = format!($($fmt)*);
17 $ctx.span_err($krate, $span, &msg, $crate::errors::Level::WARNING)
18 }};
19 ($ctx:expr, $span: expr, $($fmt:tt)*) => {{
20 let msg = format!($($fmt)*);
21 $ctx.span_err($span, &msg, $crate::errors::Level::WARNING)
22 }};
23}
24pub use register_error;
25
26#[macro_export]
28macro_rules! raise_error {
29 ($($tokens:tt)*) => {{
30 return Err(register_error!($($tokens)*));
31 }};
32}
33pub use raise_error;
34
35#[macro_export]
37macro_rules! error_assert {
38 ($ctx:expr, $span: expr, $b: expr) => {
39 if !$b {
40 $crate::errors::raise_error!($ctx, $span, "assertion failure: {:?}", stringify!($b));
41 }
42 };
43 ($ctx:expr, $span: expr, $b: expr, $($fmt:tt)*) => {
44 if !$b {
45 $crate::errors::raise_error!($ctx, $span, $($fmt)*);
46 }
47 };
48}
49pub use error_assert;
50
51#[macro_export]
53macro_rules! sanity_check {
54 ($ctx:expr, $span: expr, $b: expr) => {
55 if !$b {
56 $crate::errors::register_error!(
57 $ctx,
58 $span,
59 "assertion failure: {:?}",
60 stringify!($b)
61 );
62 }
63 };
64 ($ctx:expr, $span: expr, $b: expr, $($fmt:tt)*) => {
65 if !$b {
66 $crate::errors::register_error!($ctx, $span, $($fmt)*);
67 }
68 };
69}
70pub use sanity_check;
71
72#[derive(Debug)]
74pub struct Error {
75 pub span: Span,
76 pub msg: String,
77}
78
79impl Error {
80 pub(crate) fn render(&self, krate: &TranslatedCrate, level: Level) -> String {
81 use annotate_snippets::*;
82 let span = self.span.span;
83
84 let mut group = Group::with_title(level.title(&self.msg));
85 let origin;
86 if let Some(file) = krate.files.get(span.file_id) {
87 origin = format!("{}", file.name);
88 if let Some(source) = &file.contents {
89 let snippet = Snippet::source(source)
90 .path(&origin)
91 .fold(true)
92 .annotation(AnnotationKind::Primary.span(span.to_byte_range(source)));
93 group = group.element(snippet);
94 } else {
95 let origin = Origin::path(&origin)
97 .line(span.beg.line)
98 .char_column(span.beg.col + 1)
99 .primary(true);
100 group = group.element(origin);
101 }
102 }
103
104 Renderer::styled().render(&[group]).to_string()
105 }
106}
107
108pub fn display_unspanned_error(level: Level, msg: &str) {
110 use annotate_snippets::*;
111 let title = level.title(msg);
112 let message = Renderer::styled()
113 .render(&[Group::with_title(title)])
114 .to_string();
115 anstream::eprintln!("{message}\n");
116}
117
118#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
123pub struct DepSource {
124 pub src_id: AnyTransId,
125 pub span: Option<Span>,
128}
129
130#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, VariantIndexArity)]
132enum DepNode {
133 External(AnyTransId),
134 Local(AnyTransId, Span),
136}
137
138struct DepGraph {
140 dgraph: DiGraphMap<DepNode, ()>,
141}
142
143impl DepGraph {
144 fn new() -> Self {
145 DepGraph {
146 dgraph: DiGraphMap::new(),
147 }
148 }
149
150 fn insert_node(&mut self, n: DepNode) {
151 if !self.dgraph.contains_node(n) {
153 self.dgraph.add_node(n);
154 }
155 }
156
157 fn insert_edge(&mut self, from: DepNode, to: DepNode) {
158 self.insert_node(from);
159 self.insert_node(to);
160 if !self.dgraph.contains_edge(from, to) {
161 self.dgraph.add_edge(from, to, ());
162 }
163 }
164}
165
166impl std::fmt::Display for DepGraph {
167 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
168 for (from, to, _) in self.dgraph.all_edges() {
169 writeln!(f, "{from:?} -> {to:?}")?
170 }
171 Ok(())
172 }
173}
174
175pub struct ErrorCtx {
177 pub continue_on_failure: bool,
179 pub error_on_warnings: bool,
181
182 pub external_decls_with_errors: HashSet<AnyTransId>,
184 external_dep_graph: DepGraph,
188 pub def_id: Option<AnyTransId>,
190 pub def_id_is_local: bool,
192 pub error_count: usize,
194}
195
196impl ErrorCtx {
197 pub fn new(continue_on_failure: bool, error_on_warnings: bool) -> Self {
198 Self {
199 continue_on_failure,
200 error_on_warnings,
201 external_decls_with_errors: HashSet::new(),
202 external_dep_graph: DepGraph::new(),
203 def_id: None,
204 def_id_is_local: false,
205 error_count: 0,
206 }
207 }
208
209 pub fn continue_on_failure(&self) -> bool {
210 self.continue_on_failure
211 }
212 pub fn has_errors(&self) -> bool {
213 self.error_count > 0
214 }
215
216 pub fn display_error(
218 &self,
219 krate: &TranslatedCrate,
220 span: Span,
221 level: Level,
222 msg: String,
223 ) -> Error {
224 let error = Error { span, msg };
225 anstream::eprintln!("{}\n", error.render(krate, level));
226 error
227 }
228
229 pub fn span_err(
231 &mut self,
232 krate: &TranslatedCrate,
233 span: Span,
234 msg: &str,
235 level: Level,
236 ) -> Error {
237 let level = if level == Level::WARNING && self.error_on_warnings {
238 Level::ERROR
239 } else {
240 level
241 };
242 let err = self.display_error(krate, span, level, msg.to_string());
243 self.error_count += 1;
244 if !self.def_id_is_local
247 && let Some(id) = self.def_id
248 && self.external_decls_with_errors.insert(id)
249 {
250 self.report_external_dep_error(krate, id);
251 }
252 if !self.continue_on_failure() {
253 panic!("{msg}");
254 }
255 err
256 }
257
258 pub fn register_dep_source(
260 &mut self,
261 src: &Option<DepSource>,
262 item_id: AnyTransId,
263 is_local: bool,
264 ) {
265 if let Some(src) = src
266 && src.src_id != item_id
267 && !is_local
268 {
269 let src_node = DepNode::External(item_id);
270 self.external_dep_graph.insert_node(src_node);
271
272 let tgt_node = match src.span {
273 Some(span) => DepNode::Local(src.src_id, span),
274 None => DepNode::External(src.src_id),
275 };
276 self.external_dep_graph.insert_edge(src_node, tgt_node)
277 }
278 }
279
280 pub fn report_external_dep_error(&self, krate: &TranslatedCrate, id: AnyTransId) {
284 use annotate_snippets::*;
285
286 let graph = &self.external_dep_graph;
289 let reachable = dijkstra(&graph.dgraph, DepNode::External(id), None, |_| 1);
290 trace!("id: {:?}\nreachable:\n{:?}", id, reachable);
291
292 let by_file: HashMap<FileId, Vec<Span>> = reachable
294 .iter()
295 .filter_map(|(n, _)| match n {
296 DepNode::External(_) => None,
297 DepNode::Local(_, span) => Some(*span),
298 })
299 .into_group_map_by(|span| span.span.file_id);
300
301 let mut by_file: Vec<(FileId, _, _, Vec<Span>)> = by_file
304 .into_iter()
305 .filter_map(|(file_id, mut spans)| {
306 spans.sort(); let file = krate.files.get(file_id)?;
308 let source = file.contents.as_ref()?;
309 let file_name = file.name.to_string();
310 Some((file_id, file_name, source, spans))
311 })
312 .collect();
313 by_file.sort_by_key(|(file_id, ..)| *file_id);
315
316 let level = Level::NOTE;
317 let snippets = by_file.iter().map(|(_, origin, source, spans)| {
318 Snippet::source(*source)
319 .path(origin)
320 .fold(true)
321 .annotations(
322 spans
323 .iter()
324 .map(|span| AnnotationKind::Context.span(span.span.to_byte_range(source))),
325 )
326 });
327
328 let msg = format!(
329 "the error occurred when translating `{}`, \
330 which is (transitively) used at the following location(s):",
331 id.with_ctx(&krate.into_fmt())
332 );
333 let message = Group::with_title(level.title(&msg)).elements(snippets);
334 let out = Renderer::styled().render(&[message]).to_string();
335 anstream::eprintln!("{}", out);
336 }
337}