feat: added basic checking

Author: Zffu

Cargo.lock

@@ -74,6 +74,10 @@ pub fn has_diagnostics() -> bool {
     DIAGNOSTIC_CONTAINER.with_borrow(|f| return !f.diagnostics.is_empty())
 }
 
+pub fn get_diagnostics() -> Vec<Diagnostic> {
+    DIAGNOSTIC_CONTAINER.with_borrow(|f| return f.diagnostics.clone())
+}
+
 pub fn move_current_diagnostic_pos(pos: SpanPosition) {
     CURR_DIAGNOSTIC_POS.with_borrow_mut(|f| {
         *f = Some(pos);

compiler/diagnostics/src/lib.rs

@@ -42,7 +42,7 @@ const USE_KEYWORD_HASH: u64 = hash!("use");
 pub fn lexer_parse_file(file_path: &String) -> DiagnosticResult<Vec<LexerToken>> {
     let contents: String = match fs::read_to_string(file_path) {
         Ok(v) => v,
-        Err(_) => panic!("Couldn't read the file"),
+        Err(_) => panic!("Couldn't read the file {}", file_path),
     };
 
     let mut tokens: Vec<LexerToken> = Vec::new();

compiler/lexer/src/lexer.rs

@@ -7,3 +7,7 @@ edition = "2024"
 tower-lsp = "0.20"
 tokio = { version = "1", features = ["full"] }
 diagnostics = { path = "../compiler/diagnostics" }
+astoir = { path = "../compiler/astoir" }
+ast = { path = "../compiler/ast" }
+ast_parser = { path = "../compiler/ast_parser" }
+lexer = { path = "../compiler/lexer" }

lsp/Cargo.toml

@@ -0,0 +1,20 @@
+use ast_parser::parse_ast_ctx;
+use astoir::run_astoir_mir;
+use diagnostics::{diagnostic::Diagnostic, get_diagnostics, has_diagnostics};
+use lexer::lexer::lexer_parse_file;
+
+pub fn check_for_file(url: String) -> Vec<Diagnostic> {
+    let lexer = lexer_parse_file(&url);
+    if has_diagnostics() {
+        return get_diagnostics();
+    }
+
+    let ast = parse_ast_ctx(&lexer.unwrap());
+    if has_diagnostics() {
+        return get_diagnostics();
+    }
+
+    run_astoir_mir(ast.unwrap());
+
+    return get_diagnostics();
+}

lsp/src/bridge.rs

@@ -3,6 +3,8 @@ use tower_lsp::lsp_types::{
     Diagnostic, DiagnosticRelatedInformation, DiagnosticSeverity, Location, Position, Range, Url,
 };
 
+use crate::main;
+
 pub fn to_tower_diag(diagnostic: diagnostics::diagnostic::Diagnostic) -> Diagnostic {
     let severity = match diagnostic.level {
         Level::Error => DiagnosticSeverity::ERROR,
@@ -15,7 +17,7 @@ pub fn to_tower_diag(diagnostic: diagnostics::diagnostic::Diagnostic) -> Diagnos
     for span in diagnostic.spans {
         related_info.push(DiagnosticRelatedInformation {
             location: Location {
-                uri: Url::parse(&span.start.file_path).unwrap(),
+                uri: Url::parse(&format!("file:///{}", span.start.file_path)).unwrap(),
                 range: Range {
                     start: Position::new(span.start.line as u32, span.start.col as u32),
                     end: Position::new(span.start.line as u32, span.start.end_col as u32),
@@ -36,9 +38,23 @@ pub fn to_tower_diag(diagnostic: diagnostics::diagnostic::Diagnostic) -> Diagnos
         ),
     };
 
+    if diagnostic.primary_span.label.is_some() {
+        related_info.push(DiagnosticRelatedInformation {
+            location: Location {
+                uri: Url::parse(&format!(
+                    "file:///{}",
+                    diagnostic.primary_span.start.file_path
+                ))
+                .unwrap(),
+                range: main_range.clone(),
+            },
+            message: diagnostic.primary_span.label.unwrap(),
+        })
+    }
+
     Diagnostic {
         range: main_range,
-        message: diagnostic.primary_span.label.unwrap(),
+        message: diagnostic.message,
         severity: Some(severity),
         related_information: Some(related_info),
 

lsp/src/diags.rs

@@ -6,16 +6,18 @@ use std::{
 use tower_lsp::{
     Client, LanguageServer,
     lsp_types::{
-        CompletionOptions, HoverProviderCapability, InitializeParams, InitializeResult,
-        InitializedParams, ServerCapabilities, ServerInfo, TextDocumentSyncCapability,
-        TextDocumentSyncKind,
+        CompletionOptions, DidOpenTextDocumentParams, HoverProviderCapability, InitializeParams,
+        InitializeResult, InitializedParams, MessageType, ServerCapabilities, ServerInfo,
+        TextDocumentSyncCapability, TextDocumentSyncKind,
     },
 };
 
+use crate::{bridge::check_for_file, diags::to_tower_diag};
+
 #[derive(Debug)]
 pub struct LSPBackend {
-    lsp_client: Client,
-    documents: Arc<Mutex<HashSet<String>>>,
+    pub lsp_client: Client,
+    pub documents: Arc<Mutex<HashSet<String>>>,
 }
 
 #[tower_lsp::async_trait]
@@ -40,6 +42,27 @@ impl LanguageServer for LSPBackend {
         })
     }
 
+    async fn did_open(&self, param: DidOpenTextDocumentParams) {
+        let uri = param.text_document.uri.to_string();
+        let text = param.text_document.text;
+
+        self.documents.lock().unwrap().insert(uri.clone());
+
+        let mut diags = vec![];
+
+        self.lsp_client
+            .log_message(MessageType::ERROR, format!("Path: {}", uri))
+            .await;
+
+        for diag in check_for_file(uri.clone().replace("file://", "")) {
+            diags.push(to_tower_diag(diag))
+        }
+
+        self.lsp_client
+            .publish_diagnostics(uri.parse().unwrap(), diags, None)
+            .await;
+    }
+
     async fn shutdown(&self) -> tower_lsp::jsonrpc::Result<()> {
         Ok(())
     }

lsp/src/lsp.rs

@@ -1,4 +1,24 @@
+use std::{
+    collections::HashSet,
+    sync::{Arc, Mutex},
+};
+
+use tower_lsp::{LspService, Server};
+
+use crate::lsp::LSPBackend;
+
+pub mod bridge;
 pub mod diags;
 pub mod lsp;
 
-fn main() {}
+#[tokio::main]
+async fn main() {
+    let stdin = tokio::io::stdin();
+    let stdout = tokio::io::stdout();
+    let (service, socket) = LspService::build(|client| LSPBackend {
+        lsp_client: client,
+        documents: Arc::new(Mutex::new(HashSet::new())),
+    })
+    .finish();
+    Server::new(stdin, stdout, socket).serve(service).await;
+}