mist_api/
builder.rs

1/* 1:1 */
2use std::collections::HashMap;
3/* 2:1 */
4use std::env;
5/* 3:1 */
6use std::fs;
7/* 4:1 */
8use std::path::MAIN_SEPARATOR;
9/* 5:1 */
10use std::path::PathBuf;
11/* 6:1 */
12use std::process::Command;
13/* 7:1 */
14use std::process::Stdio;
15/* 8:1 */
16use cargo_metadata::CompilerMessage;
17/* 9:1 */
18use cargo_metadata::Message;
19/* 10:1 */
20use mist_parser::rev_mapper;
21#[derive(Debug, Clone)]
22/* 13:1 */
23pub struct MistDiagnosticMessage {
24    /* 14:5 */ pub message: String,
25    /* 15:5 */ pub file_path: PathBuf,
26    /* 16:5 */ pub file_name: String,
27    /* 17:5 */ pub line: usize,
28    /* 18:5 */ pub column: usize,
29}
30
31#[derive(Debug, Clone)]
32/* 22:1 */
33pub enum MistDiagnostic {
34    /* 23:5 */ Error (MistDiagnosticMessage),
35    /* 24:5 */ Warning (MistDiagnosticMessage),
36    /* 25:5 */ Rust (CompilerMessage),
37}
38
39/* 28:1 */
40pub fn build(mut args: Vec<String>, root: PathBuf) -> bool {
41    /* 29:5 */
42    args.remove(0);
43    /* 30:5 */
44    args.insert(1, "--message-format=json".to_string());
45    /* 32:5 */
46    let is_root = root==env::current_dir().expect("Failed getting env");
47    /* 34:5 */
48    let mut command = Command::new("cargo").args(args).stdout(Stdio::piped()).stderr(Stdio::inherit()).stdin(Stdio::inherit()).spawn().expect("Failed to run cargo");
49    /* 42:5 */
50    let mut reader = std::io::BufReader::new(command.stdout.take().expect("Failed to get reader"));
51    /* 44:5 */
52    let mut diagnostics = Vec::new();
53    /* 46:5 */
54    let mut mapping = HashMap::new();
55    /* 48:5 */
56    let mist_src = format!(".mist{MAIN_SEPARATOR}src");
57    /* 50:5 */
58    for message in cargo_metadata::Message::parse_stream(&mut reader){
59        /* 51:9 */
60        match message {            /* 52:13 */
61
62            Ok (Message::CompilerMessage (msg,),) => {
63                /* 53:17 */
64                for span in &msg.message.spans{
65                    /* 54:21 */
66                    if span.is_primary {
67                        /* 55:25 */
68                        let rust_path = root.join(&span.file_name);
69                        /* 57:25 */
70                        let mist_file = span.file_name.replacen(&mist_src, "src", 1).trim_end_matches(".rs").to_string()+".mist";
71                        /* 64:25 */
72                        let mist_path = root.join(&mist_file);
73                        /* 66:25 */
74                        if !fs::exists(&mist_path).expect("Unable to check if mist file exists") {
75                            /* 67:29 */
76                            diagnostics.push(MistDiagnostic::Rust(msg));
77                            /* 68:29 */
78                                                        break
79;
80                        }
81                        /* 71:25 */
82                        let map = mapping.entry(rust_path.clone()).or_insert_with(|| {
83                            /* 72:29 */
84                            rev_mapper::get_mapping(&fs::read_to_string(rust_path).expect("Failed to read file for mapping"))
85                        });
86                        /* 78:25 */
87                        let (_,rev_mapper::MistMap (line,column,),) = rev_mapper::find_mapping(&map, &rev_mapper::RustMap(span.line_end, span.column_start)).expect("Unable to find mapping");
88                        /* 82:25 */
89                        let mist_msg = MistDiagnosticMessage{message: format!("{}: {}",
90                                msg.message.message,
91                                span.label.clone().unwrap_or_default()),file_name: if is_root {
92                            /* 89:33 */
93                            mist_file
94                        } else {
95                            /* 91:33 */
96                            mist_path.to_string_lossy().to_string()
97                        },file_path: mist_path,line: line,column: column,};
98                        /* 98:25 */
99                        match msg.message.level {                            /* 99:29 */
100
101                            cargo_metadata::diagnostic::DiagnosticLevel::Error => {
102                                /* 100:33 */
103                                diagnostics.push(MistDiagnostic::Error(mist_msg))
104                            }                            /* 103:29 */
105
106                            cargo_metadata::diagnostic::DiagnosticLevel::Warning => {
107                                /* 104:33 */
108                                diagnostics.push(MistDiagnostic::Warning(mist_msg))
109                            }                            /* 107:29 */
110
111                            _ => {
112                            }
113                        }
114                    }
115                }
116            }            /* 113:13 */
117
118            Ok (Message::BuildFinished (finish,),) => {
119                /* 114:17 */
120                print_diagnostics(&diagnostics);
121                /* 116:17 */
122                let mut raw_reader = reader.into_inner();
123                /* 117:17 */
124                let mut stdout = std::io::stdout();
125                /* 119:17 */
126                std::io::copy(&mut raw_reader, &mut stdout).map_err(|v| v.to_string()).expect("(Mist) Failed to copy IO");
127                /* 123:17 */
128                command.wait().unwrap();
129                /* 125:17 */
130                return finish.success;
131            }            /* 128:13 */
132
133            Ok (Message::TextLine (text,),) => {println!("{text}");}            /* 129:13 */
134
135            _ => {
136            }
137        }
138    }
139    /* 133:5 */
140    false
141}/* 136:1 */
142pub fn print_diagnostics(diagnostics: &Vec<MistDiagnostic>) -> () {
143    /* 137:5 */
144    let mut files = HashMap::new();
145    /* 139:5 */
146    for diag in diagnostics{
147        /* 140:9 */
148        match diag {            /* 141:13 */
149
150            MistDiagnostic::Error (msg,) => {
151                /* 142:17 */
152                let line = get_line(&mut files, &msg);
153                /* 144:17 */
154                println!("\n{}:{}:{}\n \x1b[31mError\x1b[0m: {}\n\t{}",
155                    msg.file_name,
156                    msg.line,
157                    msg.column,
158                    msg.message,
159                    line.unwrap_or_default(),)
160            }            /* 154:13 */
161
162            MistDiagnostic::Warning (msg,) => {
163                /* 155:17 */
164                let line = get_line(&mut files, &msg);
165                /* 157:17 */
166                println!("\n{}:{}:{}\n \x1b[33mWarning\x1b[0m: {}\n\t{}",
167                    msg.file_name,
168                    msg.line,
169                    msg.column,
170                    msg.message,
171                    line.unwrap_or_default(),)
172            }            /* 167:13 */
173
174            MistDiagnostic::Rust (rs,) => {println!("{rs}")}
175        }
176    }
177}/* 172:1 */
178pub fn get_line(files: &mut HashMap<PathBuf, Vec<String>>, msg: &MistDiagnosticMessage) -> Option<String> {
179    /* 176:5 */
180    let src_path = msg.file_path.clone();
181    /* 178:5 */
182    let lines = files.entry(src_path.clone()).or_insert_with(|| {
183        /* 179:9 */
184        fs::read_to_string(src_path).expect("Unable to read mist file").lines().into_iter().map(String::from).collect()
185    });
186    /* 187:5 */
187    lines.get(msg.line-1).map(|v| v.trim().to_string())
188}
mist_api/builder.rs

mist_api/
builder.rs
