diff --git a/crates/analyzer/src/builder.rs b/crates/analyzer/src/builder.rs index 20b24c9..7f8ecfc 100644 --- a/crates/analyzer/src/builder.rs +++ b/crates/analyzer/src/builder.rs @@ -6,7 +6,7 @@ use std::{ }; use cargo_metadata::{CompilerMessage, Message}; -use mist_parser::rev_mapper::{self, RustMap, find_mapping}; +use mist_parser::rev_mapper; #[derive(Debug, Clone)] pub struct MistDiagnosticMessage { diff --git a/crates/analyzer/src/lib.rs b/crates/analyzer/src/lib.rs index d22c66f..5569ad2 100644 --- a/crates/analyzer/src/lib.rs +++ b/crates/analyzer/src/lib.rs @@ -57,29 +57,30 @@ impl Backend { match self.mapping.lock().await.get(&rs_path) { Some(mapping) => { + rs_loc // FIX: Match the find_mapping operation instead of calling .expect("Failed to map") - match rev_mapper::find_mapping( - mapping, - &rev_mapper::RustMap( - rs_loc.range.start.line as usize, - rs_loc.range.start.character as usize, - ), - ) { - Some((_, rev_mapper::MistMap(line, character))) => Location { - uri: Url::from_file_path(from_rust_to_mist(rs_path)).unwrap(), - range: Range { - start: Position { - line: line as u32 - 1, - character: character as u32, - }, - end: Position { - line: line as u32 - 1, - character: character as u32 + 1, - }, - }, - }, - None => rs_loc, - } + // match rev_mapper::find_mapping( + // mapping, + // &rev_mapper::RustMap( + // rs_loc.range.start.line as usize, + // rs_loc.range.start.character as usize, + // ), + // ) { + // Some((_, rev_mapper::MistMap(line, character))) => Location { + // uri: Url::from_file_path(from_rust_to_mist(rs_path)).unwrap(), + // range: Range { + // start: Position { + // line: line as u32 - 1, + // character: character as u32, + // }, + // end: Position { + // line: line as u32 - 1, + // character: character as u32 + 1, + // }, + // }, + // }, + // None => rs_loc, + // } } None => rs_loc, } diff --git a/crates/analyzer/src/transpiler.rs b/crates/analyzer/src/transpiler.rs index 66a316c..e3baed3 100644 --- a/crates/analyzer/src/transpiler.rs +++ b/crates/analyzer/src/transpiler.rs @@ -135,19 +135,22 @@ pub fn transpile_file(path: &Path, output_path: &Path) -> Result<(), String> { // If parsing fails, return the error string back gracefully so the LSP can show it let ast = parser_result.map_err(|e| format!("parse failed in {}:\n{}", path.display(), e))?; - let mut gc = mist_codegen::RustCodegen::new(); - let output = gc.generate(ast); + panic!(); - fs::write(output_path, output) - .map_err(|e| format!("failed to write output {}: {}", output_path.display(), e))?; + // let mut gc = mist_codegen::RustCodegen::new(); + // let output = gc.generate(ast); - Ok(()) + // fs::write(output_path, output) + // .map_err(|e| format!("failed to write output {}: {}", output_path.display(), e))?; + + // Ok(()) } pub fn transpile_text<'a>(source: &'a str) -> Result>> { - let mut gc = mist_codegen::RustCodegen::new(); + panic!(); + // let mut gc = mist_codegen::RustCodegen::new(); - Ok(gc.generate(mist_parser::parse(&source)?)) + // Ok(gc.generate(mist_parser::parse(&source)?)) } fn should_skip(source: &Path, output: &Path) -> bool { diff --git a/crates/codegen/src/lib.rs b/crates/codegen/src/lib.rs index d900a5b..6b17a85 100644 --- a/crates/codegen/src/lib.rs +++ b/crates/codegen/src/lib.rs @@ -3,11 +3,11 @@ pub mod expr; pub mod statement; pub mod top_level; -use std::collections::HashSet; +use std::path::PathBuf; use mist_parser::{ ast::*, - rev_mapper::{MistMap, RustMap}, + rev_mapper::{Mapping, MistMap, RustMap}, }; pub struct Context { @@ -27,20 +27,19 @@ pub trait GetRust { } } -#[derive(Default)] pub struct RustCodegen { output: String, indent: usize, - pub mapping: HashSet<(RustMap, MistMap)>, + pub mapping: Mapping, position: RustMap, } impl RustCodegen { - pub fn new() -> Self { + pub fn new(mist_path: PathBuf) -> Self { Self { output: String::new(), indent: 0, - mapping: HashSet::new(), + mapping: Mapping::new(mist_path), position: RustMap(1, 0), } } @@ -51,16 +50,16 @@ impl RustCodegen { fn add(&mut self, s: &str) { let newline_count = bytecount::count(s.as_bytes(), b'\n'); - + if newline_count == 0 { self.position.1 += s.len(); } else { self.position.0 += newline_count; - + let last_newline = s.rfind('\n').unwrap(); self.position.1 = s.len() - last_newline - 1; } - + self.output.push_str(s); } @@ -152,6 +151,7 @@ impl GenRust for T { impl GenRust for Spanned { fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) { cg.mapping + .map .insert((cg.position, MistMap(self.line, self.column))); self.item.gen_rust(ctx, cg); diff --git a/crates/parser/src/rev_mapper/mod.rs b/crates/parser/src/rev_mapper/mod.rs index bb08513..e943792 100644 --- a/crates/parser/src/rev_mapper/mod.rs +++ b/crates/parser/src/rev_mapper/mod.rs @@ -1,4 +1,4 @@ -use std::collections::HashSet; +use std::{collections::HashSet, path::PathBuf}; use serde::{Deserialize, Serialize}; @@ -12,15 +12,43 @@ pub struct MistMap(pub usize, pub usize); )] pub struct RustMap(pub usize, pub usize); -pub fn find_mapping( - mapping: &HashSet<(RustMap, MistMap)>, - target: &RustMap, -) -> Option<(RustMap, MistMap)> { - mapping - .iter() - .copied() - .filter(|(rust, _)| rust <= target) - .max_by_key(|(rust, _)| *rust) +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct Mapping { + pub mist_path: PathBuf, + pub map: HashSet<(RustMap, MistMap)>, +} + +impl Mapping { + pub fn new(mist_path: PathBuf) -> Self { + Self { + mist_path, + map: HashSet::new(), + } + } + + pub fn find(&self, target: &RustMap) -> Option<(RustMap, MistMap)> { + self.map + .iter() + .copied() + .filter(|(rust, _)| rust <= target) + .max_by_key(|(rust, _)| *rust) + } + + pub fn shift_rust(&mut self, lines: isize, cols: isize) { + self.map = self + .map + .iter() + .map(|(rust, mist)| (rust.shifted(lines, cols), *mist)) + .collect(); + } + + pub fn shift_mist(&mut self, lines: isize, cols: isize) { + self.map = self + .map + .iter() + .map(|(rust, mist)| (*rust, mist.shifted(lines, cols))) + .collect(); + } } impl RustMap { @@ -40,17 +68,3 @@ impl MistMap { ) } } - -pub fn shift_rust_mappings(mappings: &mut HashSet<(RustMap, MistMap)>, lines: isize, cols: isize) { - *mappings = mappings - .iter() - .map(|(rust, mist)| (rust.shifted(lines, cols), *mist)) - .collect(); -} - -pub fn shift_mist_mappings(mappings: &mut HashSet<(RustMap, MistMap)>, lines: isize, cols: isize) { - *mappings = mappings - .iter() - .map(|(rust, mist)| (*rust, mist.shifted(lines, cols))) - .collect(); -}