get_completion works but lsp doesn't

2024-06-04 22:57:57 +02:00
parent 35653cff1f
commit a6a5b46a01
5 changed files with 181 additions and 56 deletions
@@ -1,17 +1,41 @@
 // use std::collections::HashMap;
 // use std::fs;

+use std::collections::HashMap;
 use std::vec;
-
 use lspower::{self, LspService, Server};
 use lspower::jsonrpc::Result;
 use lspower::lsp::{self, *};
 use lspower::{Client, LanguageServer};
-
+use rand::{thread_rng, Rng};
+use crate::parser::{new_vars, Variable};
+use crate::transpiler::Transpiler;

 #[derive(Debug)]
 struct Backend {
-    client: Client,
+    client: Client
+}
+
+#[derive(Debug)]
+struct DocumentManager {
+    documents: HashMap<String, String>, // Key: Document URI, Value: Document content
+}
+
+impl DocumentManager {
+    fn new() -> DocumentManager {
+        DocumentManager {
+            documents: HashMap::new()
+        }
+    }
+    fn update_document(&mut self, params: DidChangeTextDocumentParams) {
+        let uri = params.text_document.uri.to_string(); // Convert URI to string
+        let content = params.content_changes.last().unwrap().text.clone(); // Access latest content
+        self.documents.insert(uri, content);
+    }
+
+    fn get_document(&self, uri: &str) -> Option<&str> {
+        self.documents.get(uri).map(|x| x.as_str())
+    }
 }

 #[lspower::async_trait]
@@ -38,9 +62,23 @@ impl LanguageServer for Backend {

    async fn completion(
        &self,
-        _params: lsp::CompletionParams,
+        params: lsp::CompletionParams,
    ) -> lspower::jsonrpc::Result<Option<lsp::CompletionResponse>> {
-        let completion_items: Vec<CompletionItem> = Vec::new();
+        // let document_manager = &self.document;
+        // let uri = params.text_document_position.text_document.uri.to_string();
+        // let document_content = document_manager.get_document(&uri).unwrap_or_default(); // Handle missing document
+    
+        // let variables = get_completion(
+        //     document_content.to_string(),
+        //     params.text_document_position.position.line as usize + 1,
+        //     params.text_document_position.position.character as usize,
+        // );
+    
+        let mut completion_items: Vec<CompletionItem> = Vec::new();
+        // for (name, _) in variables {
+        //     completion_items.push(CompletionItem::new_simple(name, "".to_string()));
+        // }
+    
        Ok(Some(CompletionResponse::Array(completion_items)))
    }

@@ -54,21 +92,40 @@ pub async fn run_lsp_server() {
    let stdin = tokio::io::stdin();
    let stdout = tokio::io::stdout();

-    let (service, messages) = LspService::new(|client| Backend { client });
+    let (service, messages) = LspService::new(|client| Backend {client});
    Server::new(stdin, stdout)
        .interleave(messages)
        .serve(service)
        .await;
 }

-// #[tokio::main]
-// pub async fn run_lsp_server() {
-//     let mut transpiler = Transpiler {
-//         var_match: String::from("x"),
-//         var_state: LexerState { line: 6, column: 9 },
-//         ..Default::default()
-//     };
-//     let file_content = fs::read_to_string("main.wt").expect("Error reading file");
-//     transpiler.transpile(file_content, 0, HashMap::new());
-//     println!("{:?}", transpiler.matched_vars);
-// }
+pub fn place_at(input: String, in2: String, line_goal: usize, column_goal: usize) -> String {
+    let mut line: usize = 1;
+    let mut column: usize = 0;
+    let mut out = String::new();
+    for c in input.chars() {
+        out+=c.to_string().as_str();
+        column += 1;
+        if c == '\n' {
+            line += 1;
+            column = 0;
+        } else if line == line_goal && column == column_goal {
+            out += in2.as_str();
+            column+=1
+        }
+    }
+    out
+}
+
+pub fn get_completion(input: String, line: usize, column: usize) -> HashMap<String, Variable> {
+    let rand_id: u32 = thread_rng().gen();
+    let rand_id: String = rand_id.to_string();
+    let mut transpiler = Transpiler {
+        peek: rand_id.clone(),
+        ..Default::default()
+    };
+    transpiler.transpile(
+        place_at(input, rand_id, line, column)
+        , 0, new_vars());
+    transpiler.matched_vars
+}
@@ -4,6 +4,7 @@ mod lsp;
 mod parser;
 mod transpiler;
 use clap::Parser;
+use parser::new_vars;
 use std::{fs, path::Path};
 use transpiler::Transpiler;

@@ -35,7 +36,7 @@ fn main() {
            }
            fs::create_dir("build").expect("error making build");
            let mut trsp = Transpiler::default();
-            let transpiled_code = trsp.transpile(file_content, 0);
+            let transpiled_code = trsp.transpile(file_content, 0, new_vars());

            match args.rust {
                Some(ref rust_file_name) => {
@@ -1,7 +1,7 @@
-use crate::lexer::{Token, TokenType};
+use crate::lexer::{LexerState, Token, TokenType};
 use once_cell::sync::Lazy;
 use regex::Regex;
-use std::fmt;
+use std::{collections::HashMap, fmt};

 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum AstType {
@@ -63,17 +63,37 @@ pub struct Parser {
    pub index: u32,
    pub include_regex: Lazy<Regex>,
    pub include_regex_local: Lazy<Regex>,
+    pub variables: HashMap<String, Variable>,
    pub json: bool,
 }

+#[derive(Clone, PartialEq, Debug)]
+pub enum VariableType {
+    Var,
+    Func,
+    Keyword,
+}
+
+#[derive(Clone, Debug)]
+pub struct Variable {
+    pub vtype: VariableType,
+    pub state: LexerState,
+}
+
+pub fn new_vars() -> HashMap<String, Variable> {
+    HashMap::from([
+        ("void".to_string(), Variable { vtype: VariableType::Keyword, state: LexerState {line:0,column:0}})
+    ])
+}
+
 impl Parser {
-    pub fn new(tokens: Vec<Token>) -> Parser {
+    pub fn new(tokens: Vec<Token>, variables: HashMap<String, Variable>) -> Parser {
        Parser {
            tokens: tokens,
            index: 0,
            include_regex: Lazy::new(|| Regex::new(r"^(#include *)<(.*?)>").unwrap()),
            include_regex_local: Lazy::new(|| Regex::new(r#"^(#include *)"(.*?)""#).unwrap()),
-            // variables: variables,
+            variables: variables,
            json: false,
        }
    }
@@ -166,6 +186,13 @@ impl Parser {
                            } else {
                                ast_res.ast_type = AstType::FunctionDeceleration;
                            }
+                            self.variables.insert(self.tokens[index + 1].clone().value, Variable {
+                                vtype: VariableType::Func,
+                                state: LexerState {
+                                    line: self.tokens[index + 1].clone().line,
+                                    column: self.tokens[index + 1].clone().column
+                                }
+                            });
                            self.index += 3;
                        } else if self.tokens.len() - index > 1
                            && self.tokens[index + 1].token_type == TokenType::Curly
@@ -186,6 +213,13 @@ impl Parser {
                                ast_res.tokens.push(self.tokens[index + 1].clone());
                                ast_res.ast_type = AstType::VariableDeceleration;
                                self.index += 1;
+                                self.variables.insert(self.tokens[index + 1].clone().value, Variable {
+                                    vtype: VariableType::Var,
+                                    state: LexerState {
+                                        line: self.tokens[index + 1].clone().line,
+                                        column: self.tokens[index + 1].clone().column
+                                    }
+                                });
                            } else if self.tokens.len() - index > 2
                                && self.tokens[index + 2].token_type == TokenType::Identifier
                                && self.tokens[index + 1].token_type == TokenType::Angle
@@ -196,6 +230,13 @@ impl Parser {
                                ast_res.tokens[0].value += ">";
                                ast_res.ast_type = AstType::VariableDeceleration;
                                self.index += 2;
+                                self.variables.insert(self.tokens[index + 1].clone().value, Variable {
+                                    vtype: VariableType::Var,
+                                    state: LexerState {
+                                        line: self.tokens[index + 1].clone().line,
+                                        column: self.tokens[index + 1].clone().column
+                                    }
+                                });
                            } else if self.tokens.len() - index > 2
                                && self.tokens[index + 1].value == "*"
                                && self.tokens[index + 2].token_type == TokenType::Identifier
@@ -203,6 +244,13 @@ impl Parser {
                                ast_res.tokens.push(self.tokens[index + 2].clone());
                                ast_res.ast_type = AstType::PointerDeceleration;
                                self.index += 2;
+                                self.variables.insert(self.tokens[index + 1].clone().value, Variable {
+                                    vtype: VariableType::Var,
+                                    state: LexerState {
+                                        line: self.tokens[index + 1].clone().line,
+                                        column: self.tokens[index + 1].clone().column
+                                    }
+                                });
                            }
                        }
                    }
@@ -1,8 +1,9 @@
 use crate::lexer::{lex, LexerState, TokenType};
-use crate::parser::{Ast, AstType, Parser};
+use crate::parser::{new_vars, Ast, AstType, Parser, Variable, VariableType};
+use std::collections::HashMap;
 use std::fs;

-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct Transpiler {
    pub state: LexerState,
    pub auto_mut: bool,
@@ -10,6 +11,8 @@ pub struct Transpiler {
    pub auto_pub: bool,
    pub macros: Vec<String>,
    pub modnum: u32,
+    pub peek: String,
+    pub matched_vars: HashMap<String, Variable>,
 }

 impl Default for Transpiler {
@@ -21,12 +24,15 @@ impl Default for Transpiler {
            auto_pub: false,
            macros: vec![String::from("println")],
            modnum: 0,
+            peek: String::new(),
+            matched_vars: HashMap::new(),
        }
    }
 }

 impl Transpiler {
-    pub fn transpile(&mut self, input: String, indent: u32) -> String {
+    pub fn transpile(&mut self, input: String, indent: u32, variables: HashMap<String, Variable>) -> String {
+        let mut variables = variables;
        let mut result = String::new();
        if indent == 0 {
            // result += "type int = i32;\n";
@@ -37,12 +43,26 @@ impl Transpiler {

        match lexer_out {
            Ok(tokens) => {
-                let mut full_ast = Parser::new(tokens.clone());
+                let mut full_ast = Parser::new(tokens.clone(), variables.clone());
                let mut last_ast = Ast {
                    ast_type: AstType::Other,
                    tokens: vec![],
                };
                for ast in full_ast.parse() {
+                    variables = full_ast.variables.clone();
+                    if ast.ast_type == AstType::Other && ast.tokens[0].token_type == TokenType::Identifier
+                        && ast.tokens[0].value.contains(&self.peek) && self.peek!="" {
+
+                        let ctoken = &ast.tokens[0];
+                        let pname = ctoken.value.split(&self.peek).next().unwrap();
+                        for (name, var) in variables.clone() {
+                            if ctoken.line > var.state.line || var.vtype != VariableType::Var {
+                                self.matched_vars.insert(name, var);
+                            }
+                        }
+                        self.peek = String::new();
+                        continue;
+                    }
                    if last_ast.tokens.len() > 0 {
                        let mut fl = 0;
                        for t in &last_ast.tokens {
@@ -71,9 +91,9 @@ impl Transpiler {
                        result += format!(
                            "fn {}({}) -> {} {}",
                            ast.tokens[1].value,
-                            self.transpile_round(ast.tokens[2].value.clone(),),
+                            self.transpile_round(ast.tokens[2].value.clone(), variables.clone()),
                            ast.tokens[0].value,
-                            self.transpile(ast.tokens[3].value.clone(), indent + 1)
+                            self.transpile(ast.tokens[3].value.clone(), indent + 1, variables.clone())
                        )
                        .as_str();
                    } else if ast.ast_type == AstType::VoidFunctionDeceleration {
@@ -83,8 +103,8 @@ impl Transpiler {
                        result += format!(
                            "fn {}({}) {}",
                            ast.tokens[1].value,
-                            self.transpile_round(ast.tokens[2].value.clone(),),
-                            self.transpile(ast.tokens[3].value.clone(), indent + 1,)
+                            self.transpile_round(ast.tokens[2].value.clone(), variables.clone()),
+                            self.transpile(ast.tokens[3].value.clone(), indent + 1, variables.clone())
                        )
                        .as_str();
                    } else if ast.ast_type == AstType::StructDeceleration {
@@ -95,7 +115,7 @@ impl Transpiler {
                            "struct {} {} {}",
                            ast.tokens[0].value,
                            "{\n",
-                            self.transpile_round(ast.tokens[1].value.clone(),)
+                            self.transpile_round(ast.tokens[1].value.clone(), variables.clone())
                                .trim_end()
                        )
                        .replace(
@@ -123,7 +143,7 @@ impl Transpiler {
                        && ast.tokens[0].token_type == TokenType::Round
                    {
                        result +=
-                            format!("({})", self.transpile_round(ast.tokens[0].value.clone(),))
+                            format!("({})", self.transpile_round(ast.tokens[0].value.clone(), variables.clone()))
                                .as_str();
                    } else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Square
                    {
@@ -134,7 +154,7 @@ impl Transpiler {
                                LexerState {
                                    line: ast.tokens[0].line,
                                    column: ast.tokens[0].column
-                                }
+                                }, variables.clone()
                            )
                        )
                        .as_str();
@@ -156,7 +176,7 @@ impl Transpiler {
                                LexerState {
                                    line: ast.tokens[0].line,
                                    column: ast.tokens[0].column,
-                                },
+                                }, variables.clone(),
                            )
                            .as_str();
                        // }
@@ -200,15 +220,15 @@ impl Transpiler {
                        result += format!(
                            "{} {} {}",
                            ast.tokens[0].value.clone(),
-                            self.transpile_round(ast.tokens[1].value.clone(),),
-                            self.transpile(ast.tokens[2].value.clone(), indent + 1,),
+                            self.transpile_round(ast.tokens[1].value.clone(), variables.clone()),
+                            self.transpile(ast.tokens[2].value.clone(), indent + 1, variables.clone()),
                        )
                        .as_str();
                    } else if ast.ast_type == AstType::State2 {
                        result += format!(
                            "{} {}",
                            ast.tokens[0].value.clone(),
-                            self.transpile(ast.tokens[1].value.clone(), indent + 1,),
+                            self.transpile(ast.tokens[1].value.clone(), indent + 1, variables.clone()),
                        )
                        .as_str();
                    } else if ast.ast_type == AstType::Namespace {
@@ -216,7 +236,7 @@ impl Transpiler {
                            "mod {} {}{}{}",
                            &ast.tokens[0].value.clone(),
                            "{",
-                            self.transpile(ast.tokens[1].value.clone(), 0),
+                            self.transpile(ast.tokens[1].value.clone(), 0, variables.clone()),
                            "}"
                        )
                        .as_str();
@@ -225,7 +245,7 @@ impl Transpiler {
                            "impl {} {}{}{}",
                            &ast.tokens[0].value.clone(),
                            "{",
-                            self.transpile(ast.tokens[1].value.clone(), 0,),
+                            self.transpile(ast.tokens[1].value.clone(), 0, variables.clone()),
                            "}"
                        )
                        .as_str();
@@ -313,7 +333,7 @@ impl Transpiler {
            self.clone().modnum
        );
        let file_content = fs::read_to_string(s.to_string() + modfile).expect("Error reading file");
-        let transpiled_code = self.transpile(file_content, 0);
+        let transpiled_code = self.transpile(file_content, 0, new_vars());
        fs::write(
            ("build/".to_string() + modname.as_str()) + ".rs",
            transpiled_code,
@@ -321,12 +341,12 @@ impl Transpiler {
        .expect("Error writing file");
        modname
    }
-    pub fn transpile_round(&mut self, input: String) -> String {
+    pub fn transpile_round(&mut self, input: String, variables: HashMap<String, Variable>) -> String {
        let mut result = String::new();
        let lexer_out = lex(input.as_str(), false, self.state);
        match lexer_out {
            Ok(tokens) => {
-                let mut full_ast = Parser::new(tokens.clone());
+                let mut full_ast = Parser::new(tokens.clone(), variables.clone());
                let mut last_ast = Ast {
                    ast_type: AstType::Other,
                    tokens: vec![],
@@ -364,7 +384,7 @@ impl Transpiler {
                    } else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Round
                    {
                        result +=
-                            format!("({})", self.transpile_round(ast.tokens[0].value.clone(),))
+                            format!("({})", self.transpile_round(ast.tokens[0].value.clone(), variables.clone()))
                                .as_str();
                    } else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Square
                    {
@@ -375,7 +395,7 @@ impl Transpiler {
                                LexerState {
                                    line: ast.tokens[0].line,
                                    column: ast.tokens[0].column
-                                }
+                                }, variables.clone()
                            )
                        )
                        .as_str();
@@ -389,7 +409,7 @@ impl Transpiler {
                                LexerState {
                                    line: ast.tokens[0].line,
                                    column: ast.tokens[0].column,
-                                },
+                                }, variables.clone(),
                            )
                            .as_str();
                    } else if ast.ast_type == AstType::StructCall {
@@ -416,12 +436,12 @@ impl Transpiler {
        }
    }

-    pub fn transpile_square(&mut self, input: String, state: LexerState) -> String {
+    pub fn transpile_square(&mut self, input: String, state: LexerState, variables: HashMap<String, Variable>) -> String {
        let mut result = String::new();
        let lexer_out = lex(input.as_str(), false, state);
        match lexer_out {
            Ok(tokens) => {
-                let mut full_ast = Parser::new(tokens.clone());
+                let mut full_ast = Parser::new(tokens.clone(), variables.clone());
                let mut last_ast = Ast {
                    ast_type: AstType::Other,
                    tokens: vec![],
@@ -457,7 +477,7 @@ impl Transpiler {
                    } else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Round
                    {
                        result +=
-                            format!("({})", self.transpile_round(ast.tokens[0].value.clone(),))
+                            format!("({})", self.transpile_round(ast.tokens[0].value.clone(), variables.clone()))
                                .as_str();
                    } else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Square
                    {
@@ -468,7 +488,7 @@ impl Transpiler {
                                LexerState {
                                    line: ast.tokens[0].line,
                                    column: ast.tokens[0].column
-                                }
+                                }, variables.clone()
                            )
                        )
                        .as_str();
@@ -482,7 +502,7 @@ impl Transpiler {
                                LexerState {
                                    line: ast.tokens[0].line,
                                    column: ast.tokens[0].column,
-                                },
+                                }, variables.clone(),
                            )
                            .as_str();
                    } else if ast.ast_type == AstType::StructCall {
@@ -506,12 +526,12 @@ impl Transpiler {
        }
    }

-    pub fn transpile_json(&mut self, input: String, state: LexerState) -> String {
+    pub fn transpile_json(&mut self, input: String, state: LexerState, variables: HashMap<String, Variable>) -> String {
        let mut result = String::new();
        let lexer_out = lex(input.as_str(), false, state);
        match lexer_out {
            Ok(tokens) => {
-                let mut full_ast = Parser::new(tokens.clone());
+                let mut full_ast = Parser::new(tokens.clone(), variables.clone());
                full_ast.json = true;
                result += "HashMap::from([";
                let mut last_ast = Ast {
@@ -549,7 +569,7 @@ impl Transpiler {
                    } else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Round
                    {
                        result +=
-                            format!("({})", self.transpile_round(ast.tokens[0].value.clone(),))
+                            format!("({})", self.transpile_round(ast.tokens[0].value.clone(), variables.clone()))
                                .as_str();
                    } else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Square
                    {
@@ -560,7 +580,7 @@ impl Transpiler {
                                LexerState {
                                    line: ast.tokens[0].line,
                                    column: ast.tokens[0].column
-                                }
+                                }, variables.clone()
                            )
                        )
                        .as_str();
@@ -572,7 +592,7 @@ impl Transpiler {
                                LexerState {
                                    line: ast.tokens[0].line,
                                    column: ast.tokens[0].column,
-                                },
+                                }, variables.clone(),
                            )
                            .as_str();
                    } else {