ezno 0.0.21

A JavaScript type checker and compiler. For use as a library or through the CLI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use codespan_reporting::{
	diagnostic::{Diagnostic, Label, Severity},
	term::{
		emit,
		termcolor::{BufferedStandardStream, ColorChoice},
		Config, DisplayStyle,
	},
};

use checker::source_map::{MapFileStore, PathMap, SourceId};

fn ezno_diagnostic_to_severity(kind: &checker::DiagnosticKind) -> Severity {
	match kind {
		checker::DiagnosticKind::Error => Severity::Error,
		checker::DiagnosticKind::Warning => Severity::Warning,
		checker::DiagnosticKind::Info => Severity::Note,
	}
}

/// If pretty printing, it looks nice to include the message under the label, rather than as a heading. However under
/// compact mode the label isn't printed, so instead do the opposite in the compact case
fn checker_diagnostic_to_codespan_diagnostic(
	diagnostic: checker::Diagnostic,
	compact: bool,
) -> Diagnostic<SourceId> {
	match diagnostic {
		checker::Diagnostic::Global { reason, kind } => Diagnostic {
			severity: ezno_diagnostic_to_severity(&kind),
			code: None,
			message: reason,
			labels: Vec::new(),
			notes: Vec::default(),
		},
		checker::Diagnostic::Position { reason, position, kind } => {
			let (message, labels) = if compact {
				(reason, Vec::new())
			} else {
				(
					String::new(),
					vec![Label::primary(position.source, position).with_message(reason)],
				)
			};

			Diagnostic {
				severity: ezno_diagnostic_to_severity(&kind),
				code: None,
				message,
				labels,
				notes: Vec::default(),
			}
		}
		checker::Diagnostic::PositionWithAdditionalLabels { reason, position, labels, kind } => {
			let mut diagnostic = Diagnostic {
				severity: ezno_diagnostic_to_severity(&kind),
				code: None,
				message: String::new(),
				labels: Vec::new(),
				notes: Vec::new(),
			};

			if compact {
				diagnostic.message = reason;
			} else {
				let main_label = Label::primary(position.source, position).with_message(reason);
				diagnostic.labels.push(main_label);

				for (message, position) in labels {
					diagnostic
						.labels
						.push(Label::secondary(position.source, position).with_message(message));
				}
			}

			diagnostic
		}
	}
}

pub(crate) fn emit_diagnostics<T: PathMap>(
	diagnostics: impl IntoIterator<Item = checker::Diagnostic>,
	fs: &MapFileStore<T>,
	compact: bool,
) -> Result<(), codespan_reporting::files::Error> {
	// TODO custom here
	let config = Config {
		display_style: if compact { DisplayStyle::Short } else { DisplayStyle::Rich },
		..Config::default()
	};

	#[cfg(not(target_family = "wasm"))]
	let mut writer = BufferedStandardStream::stderr(ColorChoice::Auto);

	let files = fs.into_code_span_store();

	for diagnostic in diagnostics {
		let diagnostic = checker_diagnostic_to_codespan_diagnostic(diagnostic, compact);

		#[cfg(target_family = "wasm")]
		{
			let mut buffer = codespan_reporting::term::termcolor::Buffer::ansi();
			emit(&mut buffer, &config, &files, &diagnostic)?;
			let output =
				String::from_utf8(buffer.into_inner()).expect("invalid string from diagnostic");
			crate::utilities::print_to_cli(format_args!("{output}"));
		}

		#[cfg(not(target_family = "wasm"))]
		emit(&mut writer, &config, &files, &diagnostic)?;
	}

	Ok(())
}