fix completion

src/completion.rs

@@ -1,6 +1,6 @@
 use crate::server::LSPServer;
 use crate::sources::LSPSupport;
-use log::{debug, trace};
+use log::{debug, info, log, trace};
 use ropey::{Rope, RopeSlice};
 use std::time::Instant;
 use tower_lsp::lsp_types::*;
@@ -24,6 +24,9 @@ impl LSPServer {
             file.text.line(doc.position.line as usize),
             doc.position,
         );
+
+        // info!("trigger completion token: {}", token);
+
         let response = match params.context {
             Some(context) => match context.trigger_kind {
                 CompletionTriggerKind::TRIGGER_CHARACTER => {
@@ -56,6 +59,8 @@ impl LSPServer {
                         file.text.pos_to_byte(&doc.position),
                         &doc.text_document.uri,
                     )?;
+
+                    
                     // complete keywords
                     comps.items.extend::<Vec<CompletionItem>>(
                         self.key_comps

src/definition.rs

@@ -1,7 +1,7 @@
 use crate::definition::extract_defs::get_ident;
 use crate::server::LSPServer;
 use crate::sources::LSPSupport;
-use log::{debug, trace};
+use log::{debug, info, trace};
 use ropey::{Rope, RopeSlice};
 use sv_parser::*;
 use tower_lsp::lsp_types::*;
@@ -21,12 +21,20 @@ impl LSPServer {
         let file = self.srcs.get_file(file_id)?;
         let file = file.read().ok()?;
         let token = get_definition_token(file.text.line(pos.line as usize), pos);
-        debug!("goto definition, token: {}", &token);
+        
+        // info!("definition token: {}", token);
+        
         let scope_tree = self.srcs.scope_tree.read().ok()?;
+
+        self.key_comps
+
+        // info!("scope tree: {:?}", scope_tree);
+
         trace!("{:#?}", scope_tree.as_ref()?);
         let def = scope_tree
             .as_ref()?
             .get_definition(&token, file.text.pos_to_byte(&pos), &doc)?;
+
         let def_pos = file.text.byte_to_pos(def.byte_idx());
         debug!("def: {:?}", def_pos);
         Some(GotoDefinitionResponse::Scalar(Location::new(
@@ -123,7 +131,7 @@ fn get_definition_token(line: RopeSlice, pos: Position) -> String {
         line_iter.next();
     }
     let mut c = line_iter.prev();
-    while c.is_some() && (c.unwrap().is_alphanumeric() || c.unwrap() == '_') {
+    while c.is_some() && (c.unwrap().is_alphanumeric() || c.unwrap() == '_' || c.unwrap() == '`') {
         token.push(c.unwrap());
         c = line_iter.prev();
     }

src/definition/def_types.rs

@@ -1,5 +1,5 @@
 use crate::sources::LSPSupport;
-use log::trace;
+use log::{info, trace};
 use ropey::Rope;
 use tower_lsp::lsp_types::*;
 
@@ -118,12 +118,16 @@ pub trait Scope: std::fmt::Debug + Definition + Sync + Send {
                 break;
             }
         }
+
+        let lowerCaseToken = token.to_lowercase();
         // now that we are in the users scope, we can attempt to find a relevant completion
         // we proceed back upwards through the scope tree, adding any definitions that match
         // the users token
         let completion_idents: Vec<String> = completions.iter().map(|x| x.label.clone()).collect();
         for def in self.defs() {
-            if !completion_idents.contains(&def.ident()) && def.starts_with(token) {
+            // info!("current def: {:?}, trigger token: {}, contain: {}, start with: {}", def, token, completion_idents.contains(&def.ident()), def.starts_with(token));
+            
+            if !completion_idents.contains(&def.ident()) && def.ident().to_lowercase().starts_with(&lowerCaseToken) {
                 completions.push(def.completion());
             }
         }

src/main.rs

@@ -33,11 +33,11 @@ async fn main() {
     let stdin = tokio::io::stdin();
     let stdout = tokio::io::stdout();
 
-    // let (service, socket) = LspService::new(|client| Arc::new(Backend::new(client, log_handle)));
+    let (service, socket) = LspService::new(|client| Arc::new(Backend::new(client, log_handle)));
 
-    let (service, socket) = LspService::build(|client| Arc::new(Backend::new(client, log_handle)))
+    // let (service, socket) = LspService::build(|client| Arc::new(Backend::new(client, log_handle)))
-        .custom_method("custom/request", customRequest)
+    //     .custom_method("custom/request", customRequest)
-        .finish();
+    //     .finish();
 
     Server::new(stdin, stdout, socket)
         .serve(service)