mist-go/mist
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 11 Wiki Activity

Merge pull request #81 from mist-go/analyzer-patch

Browse Source 
VC: LSP Analyzer patch
This commit is contained in:
selimaj-dev
2026-06-21 17:10:48 +02:00
committed by GitHub
parent 0dd1016980 d1335bb613
commit 16803aa0f6
9 changed files with 721 additions and 810 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/analyzer/src/builder.rs
-139
View File
@@ -1,139 +0,0 @@
use std::{
collections::HashMap,
env, fs,
path::{MAIN_SEPARATOR, PathBuf},
process::{Command, Stdio},
};
use cargo_metadata::{CompilerMessage, Message};
use mist_parser::rev_mapper;
#[derive(Debug, Clone)]
pub struct MistDiagnosticMessage {
pub message: String,
pub file_path: PathBuf,
pub file_name: String,
pub line: usize,
pub column: usize,
}
#[derive(Debug, Clone)]
pub enum MistDiagnostic {
Error(MistDiagnosticMessage),
Warning(MistDiagnosticMessage),
Rust(CompilerMessage),
}
pub fn build(mut args: Vec<String>, root: PathBuf) -> Vec<MistDiagnostic> {
args.insert(1, "--message-format=json".to_string());
let is_root = root == env::current_dir().expect("Failed getting env");
let mut command = Command::new("cargo")
.args(args)
.stdout(Stdio::piped())
.spawn()
.expect("Failed to run cargo");
let mut reader = std::io::BufReader::new(command.stdout.take().expect("Failed to get reader"));
let mut diagnostics = Vec::new();
let mut mapping: HashMap<rev_mapper::RustMap, rev_mapper::MistMap> = HashMap::new();
let mist_src = format!(".mist{MAIN_SEPARATOR}lsp");
for message in cargo_metadata::Message::parse_stream(&mut reader) {
match message {
Ok(Message::CompilerMessage(msg)) => {
for span in &msg.message.spans {
if span.is_primary {
let rust_path = root.join(&span.file_name);
let mist_file = span
.file_name
.replacen(&mist_src, "src", 1)
.trim_end_matches(".rs")
.to_string()
+ ".mist";
let mist_path = root.join(&mist_file);
if !fs::exists(&mist_path).expect("Unable to check if mist file exists") {
diagnostics.push(MistDiagnostic::Rust(msg));
break;
}
// let map = mapping.entry(rust_path.clone()).or_insert_with(|| {
// get_mapping(
// &fs::read_to_string(rust_path)
// .expect("Failed to read file for mapping"),
// )
// });
// let mist_span =
// find_mapping(&map, &RustMap(span.line_end, span.column_start))
// .expect("Unable to find mapping");
// let mist_msg = MistDiagnosticMessage {
// message: format!(
// "{}: {}",
// msg.message.message,
// span.label.clone().unwrap_or_default()
// ),
// file_name: if is_root {
// mist_file
// } else {
// mist_path.to_string_lossy().to_string()
// },
// file_path: mist_path,
// line: mist_span.1.0,
// column: mist_span.1.1,
// };
// match msg.message.level {
// cargo_metadata::diagnostic::DiagnosticLevel::Error => {
// diagnostics.push(MistDiagnostic::Error(mist_msg))
// }
// cargo_metadata::diagnostic::DiagnosticLevel::Warning => {
// diagnostics.push(MistDiagnostic::Warning(mist_msg))
// }
// _ => {}
// }
}
}
}
Ok(Message::BuildFinished(_)) => {
command.wait().unwrap();
return diagnostics;
}
Ok(Message::TextLine(text)) => println!("{text}"),
_ => {}
}
}
diagnostics
}
pub fn get_line(
files: &mut HashMap<PathBuf, Vec<String>>,
msg: &MistDiagnosticMessage,
) -> Option<String> {
let src_path = msg.file_path.clone();
let lines = files.entry(src_path.clone()).or_insert_with(|| {
fs::read_to_string(src_path)
.expect("Unable to read mist file")
.lines()
.into_iter()
.map(String::from)
.collect()
});
lines.get(msg.line - 1).map(|v| v.trim().to_string())
}
crates/analyzer/src/lib.rs
+578 -464
View File
File diff suppressed because it is too large Load Diff
crates/analyzer/src/rust_analyzer.rs
+69 -18
View File
@@ -35,11 +35,9 @@ type PendingMap = Arc<Mutex<HashMap<usize, oneshot::Sender<Result<Value, String>
#[derive(Debug)]
pub struct RustAnalyzer {
// Wrapped in a Mutex to support safe concurrent sharing if the design expands
stdin: Arc<Mutex<tokio::process::ChildStdin>>,
pending: PendingMap,
id: usize,
// Keep child handler to explicitly manage child process lifecycle and prevent zombie processes
_child: tokio::process::Child,
}
@@ -60,7 +58,6 @@ async fn read_lsp_message<R: AsyncBufReadExt + Unpin>(
let mut line = String::new();
let mut content_length = 0;
// Guard against infinite header reading attacks/bugs (Max 100 headers)
for _ in 0..100 {
line.clear();
let bytes_read = reader.read_line(&mut line).await?;
@@ -74,7 +71,6 @@ async fn read_lsp_message<R: AsyncBufReadExt + Unpin>(
}
}
// Explode early if payload size violates strict guard rails to prevent memory-exhaustion (OOM)
if content_length == 0 {
return Err("Missing, invalid, or zero Content-Length header".into());
}
@@ -86,7 +82,6 @@ async fn read_lsp_message<R: AsyncBufReadExt + Unpin>(
.into());
}
// Explicitly secure pre-allocation limit
let mut buffer = vec![0u8; content_length];
reader.read_exact(&mut buffer).await?;
@@ -94,7 +89,9 @@ async fn read_lsp_message<R: AsyncBufReadExt + Unpin>(
}
impl RustAnalyzer {
pub fn new() -> Result<Self, Box<dyn std::error::Error + Send + Sync>> {
pub fn new(
notification_tx: tokio::sync::mpsc::UnboundedSender<Value>,
) -> Result<Self, Box<dyn std::error::Error + Send + Sync>> {
let mut child = tokio::process::Command::new("rust-analyzer")
.stdin(Stdio::piped())
.stdout(Stdio::piped())
@@ -113,7 +110,6 @@ impl RustAnalyzer {
let pending: PendingMap = Arc::new(Mutex::new(HashMap::new()));
let pending_clone = pending.clone();
// Background supervisor task loop
tokio::spawn(async move {
let mut stdout = BufReader::new(stdout);
@@ -122,7 +118,6 @@ impl RustAnalyzer {
Ok(v) => v,
Err(err) => {
eprintln!("LSP fatal stream read failure: {err}");
// CRITICAL: Notify all pending channels that the bridge broke down
let mut lock = pending_clone.lock().await;
for (_, tx) in lock.drain() {
let _ = tx.send(Err(format!("LSP reader task dropped: {}", err)));
@@ -135,12 +130,14 @@ impl RustAnalyzer {
Ok(v) => v,
Err(err) => {
eprintln!("Corrupted JSON received: {err}");
continue; // Keep the connection running despite malformed frame
continue;
}
};
// Filter server notification frames
if value.get("method").is_some() && value.get("id").is_none() {
let is_notification = value.get("method").is_some() && value.get("id").is_none();
if is_notification {
let _ = notification_tx.send(value);
continue;
}
@@ -181,7 +178,6 @@ impl RustAnalyzer {
let (tx, rx) = oneshot::channel();
// Scope the lock allocation tightly
{
self.pending.lock().await.insert(id, tx);
}
@@ -193,19 +189,15 @@ impl RustAnalyzer {
"params": params,
});
// Acquire lock on writing stream to ensure thread safety
let mut stdin_lock = self.stdin.lock().await;
if let Err(err) = send_lsp_message(&mut *stdin_lock, &payload).await {
// Rollback the pending map operation to avoid internal memory memory-leaks if serialization/IO errors trigger
self.pending.lock().await.remove(&id);
return Err(Box::new(err));
}
// Explicit drop of write lock early so other operations can pipe messages synchronously
drop(stdin_lock);
// Enforce an absolute time constraint limit to break free from hanging processes
let response_payload = match timeout(REQUEST_TIMEOUT, rx).await {
Ok(Ok(Ok(value))) => value,
Ok(Ok(Err(task_err))) => return Err(task_err.into()),
@@ -215,7 +207,6 @@ impl RustAnalyzer {
);
}
Err(_timeout_elapsed) => {
// Clear state tracking entries dynamically upon expiration failure
self.pending.lock().await.remove(&id);
return Err(
format!("Request ID {} timed out after {:?}", id, REQUEST_TIMEOUT).into(),
@@ -290,8 +281,68 @@ impl RustAnalyzer {
}
pub async fn initialized(&mut self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
self.notify(Initialized::METHOD, InitializedParams {})
self.notify(
<Initialized as Notification>::METHOD,
InitializedParams {},
)
.await?;
Ok(())
}
}
impl RustAnalyzer {
pub async fn did_open(
&mut self,
uri: Url,
text: &str,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
self.notify(
"textDocument/didOpen",
json!({
"textDocument": {
"uri": uri,
"languageId": "rust",
"version": 1,
"text": text,
}
}),
)
.await
}
pub async fn did_change(
&mut self,
uri: Url,
text: &str,
version: i32,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
self.notify(
"textDocument/didChange",
json!({
"textDocument": {
"uri": uri,
"version": version,
},
"contentChanges": [{
"text": text,
}],
}),
)
.await
}
pub async fn did_close(
&mut self,
uri: Url,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
self.notify(
"textDocument/didClose",
json!({
"textDocument": {
"uri": uri,
}
}),
)
.await
}
}
crates/analyzer/src/transpiler.rs
+29 -151
View File
@@ -1,163 +1,41 @@
use std::{
fs,
path::{Path, PathBuf},
};
use std::path::{Path, PathBuf};
use mist_parser::{ast::TopLevel, error::ParseError};
use mist_codegen::{GetRust, RustCodegen};
use mist_parser::rev_mapper::Mapping;
use mist_parser::{parse, parse_module};
pub fn build(root: &PathBuf) {
let src_dir = root.join("src");
let out_dir = root.join(".mist/src");
if let Err(e) = build_dir(root, &src_dir, &src_dir, &out_dir) {
eprintln!("Warning: Build directory run aborted safely: {e}");
}
pub struct TranspiledFile {
pub mist_path: PathBuf,
pub rust_path: PathBuf,
pub rust_content: String,
pub mapping: Mapping,
}
fn build_dir(
root: &Path,
base_src: &Path,
current_dir: &Path,
out_dir: &Path,
) -> Result<(), String> {
let entries = fs::read_dir(current_dir)
.map_err(|e| format!("failed to read directory {}: {}", current_dir.display(), e))?;
pub fn transpile_mist(mist_path: &Path, source: &str) -> Result<TranspiledFile, String> {
let module_decl = parse_module(source).map_err(|e| format!("parse module error: {e:?}"))?;
let rust_path = crate::from_mist_to_rust(mist_path.to_path_buf());
for entry in entries {
let entry = match entry {
Ok(entry) => entry,
Err(e) => {
eprintln!("Warning: Skipping invalid directory entry: {e}");
continue; // Skip corrupted entry instead of crashing
}
};
let parsed = parse(source).map_err(|e| format!("parse error: {e:?}"))?;
let path = entry.path();
// Recurse into nested directories
if path.is_dir() {
if let Err(e) = build_dir(root, base_src, &path, out_dir) {
eprintln!("Warning: Nested build directory failed: {e}");
}
continue;
for item in &parsed {
mist_parser::semantics::check_class_semantics(item)
.map_err(|e| format!("semantic error: {}", e[0].error_message))?;
}
// Safe prefix stripping fallback
let relative = match path.strip_prefix(base_src) {
Ok(p) => p,
Err(_) => {
eprintln!(
"Warning: Path {} is outside base source directory",
path.display()
);
continue;
}
};
let mut codegen = RustCodegen::new(mist_path.to_path_buf());
let output = codegen.generate(parsed);
// Handle non-mist files with a cache check
if path.extension().and_then(|e| e.to_str()) != Some("mist") {
let dest_path = out_dir.join(relative);
let mod_prefix = module_decl
.as_ref()
.map(|(vis, name)| format!("{}mod {};\n", vis.get_rust(), name.get_rust()))
.unwrap_or_default();
// Create parent directories for static assets if needed
if let Some(parent) = dest_path.parent() {
let _ = fs::create_dir_all(parent);
}
codegen.mapping.shift_rust(mod_prefix.lines().count() as isize, 0);
if should_skip(&path, &dest_path) {
continue;
}
if let Err(e) = fs::copy(&path, &dest_path) {
eprintln!(
"Warning: Failed to copy non-mist file {}: {}",
path.display(),
e
);
}
continue;
}
let output_path = out_dir.join(relative).with_extension("rs");
// Cache layer: Skip if the generated .rs file is newer than the .mist source
if should_skip(&path, &output_path) {
continue;
}
if let Err(e) = transpile_file(&path, &output_path) {
eprintln!(
"Warning: Transpilation failed for {}: {}",
path.display(),
e
);
}
}
Ok(())
}
pub fn transpile_file(path: &Path, output_path: &Path) -> Result<(), String> {
// Create parent directories
if let Some(parent) = output_path.parent() {
fs::create_dir_all(parent).map_err(|e| {
format!(
"failed to create output directory {}: {}",
parent.display(),
e
)
})?;
}
// Read source
let source = fs::read_to_string(path)
.map_err(|e| format!("failed to read file {}: {}", path.display(), e))?;
let parser_result = mist_parser::parse(&source).map_err(|e| match e {
ParseError::Ast(e) => {
// Using components carefully to prevent out-of-bounds or zero layout crashes
let start_pos = e.span.start_pos().line_col();
let span = e.span.as_str();
format!(
"\n{}:{}:{}\n Error: {}\n\t{}{}\t{}",
path.display(),
start_pos.0,
start_pos.1,
e.error_message,
span,
if span.ends_with('\n') { "" } else { "\n" },
"^".repeat(span.trim().len()),
)
}
ParseError::PreAst(e) => format!("{e}"),
});
// 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))?;
panic!();
// let mut gc = mist_codegen::RustCodegen::new();
// let output = gc.generate(ast);
// 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<String, ParseError<'a, Vec<TopLevel>>> {
panic!();
// let mut gc = mist_codegen::RustCodegen::new();
// Ok(gc.generate(mist_parser::parse(&source)?))
}
fn should_skip(source: &Path, output: &Path) -> bool {
if let (Ok(src_meta), Ok(out_meta)) = (fs::metadata(source), fs::metadata(output)) {
if let (Ok(src_time), Ok(out_time)) = (src_meta.modified(), out_meta.modified()) {
return out_time >= src_time;
}
}
false
Ok(TranspiledFile {
mist_path: mist_path.to_path_buf(),
rust_path,
rust_content: format!("{}{}", mod_prefix, output),
mapping: codegen.mapping,
})
}
crates/codegen/src/class_decl.rs
+7 -11
View File
@@ -2,7 +2,7 @@ use std::collections::HashMap;
use mist_parser::ast::*;
use crate::{Context, GenRust, GetRust, RustCodegen};
use crate::{Context, GenRust, GenSpanTranslation, GetRust, RustCodegen};
pub struct ClassProcessedData {
visibility: Visibility,
@@ -117,7 +117,7 @@ impl ClassProcessedData {
}
for field in &self.fields {
cg.add_indentedln(&field.get_comment());
field.gen_span(cg);
cg.add_indentedln(&field.item.decl.get_rust());
}
@@ -269,7 +269,7 @@ impl ClassProcessedData {
}
if let TypeExpr::Ref { mutable, .. } = params.remove(0) {
cg.add_indentedln(&method.get_comment());
method.gen_span(cg);
cg.add_indented(&format!("{}::__m_", target_rust_path));
cg.add(&method.item.name.get_rust());
cg.add(" as ");
@@ -302,7 +302,7 @@ impl ClassProcessedData {
for (override_tier, v) in &self.override_v_table {
if let Some(path) = &override_tier.0 {
cg.add_indentedln(&v.get_comment());
v.gen_span(cg);
// This forces the compiler to statically verify that &Self can Deref into &Target
cg.add_indentedln(&format!("let _: &{} = this;", path.get_rust()));
}
@@ -319,10 +319,8 @@ impl ClassProcessedData {
ctx: &mut Context,
cg: &mut RustCodegen,
) {
let constructor_comment = constructor.get_comment();
cg.add_indentedln("#[allow(invalid_value)]");
cg.add_indentedln(&constructor_comment);
constructor.gen_span(cg);
cg.add_indented(&format!(
"{}fn new{}(",
@@ -357,10 +355,8 @@ impl ClassProcessedData {
cg.add_indentedln("this._vptr = &Self::__V_TABLE;");
for field in &self.fields {
let comment = field.get_comment();
if let Some(init) = &field.item.init {
cg.add_indentedln(&comment);
field.gen_span(cg);
cg.add_indentedln(&format!("this.{} = ", field.item.decl.name.get_rust()));
init.gen_rust(ctx, cg);
}
@@ -378,7 +374,7 @@ impl ClassProcessedData {
cg.add_indentedln("this._vptr = &Self::__V_TABLE;");
cg.add_indentedln(&constructor_comment);
constructor.gen_span(cg);
cg.add_indentedln("this");
cg.indent -= 1;
crates/codegen/src/lib.rs
+13 -4
View File
@@ -142,6 +142,18 @@ impl GenRust for Attribute {
}
}
pub trait GenSpanTranslation {
fn gen_span(&self, _cg: &mut RustCodegen);
}
impl<T> GenSpanTranslation for Spanned<T> {
fn gen_span(&self, cg: &mut RustCodegen) {
cg.mapping
.map
.insert((cg.position, MistMap(self.line, self.column)));
}
}
impl<T: GetRust> GenRust for T {
fn gen_rust(&self, _: &mut Context, cg: &mut RustCodegen) {
cg.add(&self.get_rust());
@@ -150,10 +162,7 @@ impl<T: GetRust> GenRust for T {
impl<T: GenRust> GenRust for Spanned<T> {
fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
cg.mapping
.map
.insert((cg.position, MistMap(self.line, self.column)));
self.gen_span(cg);
self.item.gen_rust(ctx, cg);
}
}
crates/codegen/src/statement.rs
+2 -2
View File
@@ -1,6 +1,6 @@
use mist_parser::ast::*;
use crate::Context;
use crate::{Context, GenSpanTranslation};
use crate::{GenRust, GetRust, RustCodegen};
@@ -55,7 +55,7 @@ impl GenRust for Statement {
cg.indent += 1;
for match_item in match_items {
cg.add_indentedln(&match_item.get_comment());
match_item.gen_span(cg);
let MatchItem(pat, body) = &match_item.item;
crates/parser/src/ast/mod.rs
-6
View File
@@ -72,9 +72,3 @@ impl From<GenericsDecl> for Generics {
Self(value.0.into_iter().map(Generic::from).collect())
}
}
impl<T> Spanned<T> {
pub fn get_comment(&self) -> String {
format!("/* {}:{} */", self.line, self.column)
}
}
crates/parser/src/rev_mapper.rs
+8
View File
@@ -34,6 +34,14 @@ impl Mapping {
.max_by_key(|(rust, _)| *rust)
}
pub fn find_by_mist(&self, target: &MistMap) -> Option<(RustMap, MistMap)> {
self.map
.iter()
.copied()
.filter(|(_, mist)| mist <= target)
.max_by_key(|(_, mist)| *mist)
}
pub fn shift_rust(&mut self, lines: isize, cols: isize) {
self.map = self
.map