changes

Author: juleswritescode

crates/pg_cli/src/commands/daemon.rs

@@ -111,6 +111,7 @@ pub(crate) fn lsp_proxy(
     log_file_name_prefix: Option<String>,
 ) -> Result<(), CliDiagnostic> {
     let rt = Runtime::new()?;
+    println!("Starting LSP Proxy…");
     rt.block_on(start_lsp_proxy(
         &rt,
         config_path,

crates/pg_lsp_new/src/handlers/text_document.rs

@@ -5,7 +5,7 @@ use pg_workspace_new::workspace::{
     ChangeFileParams, ChangeParams, CloseFileParams, GetFileContentParams, OpenFileParams,
 };
 use tower_lsp::lsp_types;
-use tracing::{error, field};
+use tracing::{error, field, info};
 
 /// Handler for `textDocument/didOpen` LSP notification
 #[tracing::instrument(
@@ -43,36 +43,48 @@ pub(crate) async fn did_open(
 }
 
 // Handler for `textDocument/didChange` LSP notification
-#[tracing::instrument(level = "debug", skip_all, fields(url = field::display(&params.text_document.uri), version = params.text_document.version), err)]
+#[tracing::instrument(level = "info", skip_all, fields(url = field::display(&params.text_document.uri), version = params.text_document.version), err)]
 pub(crate) async fn did_change(
     session: &Session,
     params: lsp_types::DidChangeTextDocumentParams,
 ) -> Result<()> {
     let url = params.text_document.uri;
     let version = params.text_document.version;
 
+    info!("Reading LSP Path...");
+
     let pglsp_path = session.file_path(&url)?;
 
+    info!("Getting file content...");
+
     // we need to keep the documents here too for the line index
     let old_text = session.workspace.get_file_content(GetFileContentParams {
         path: pglsp_path.clone(),
     })?;
 
+    info!("Finding start…");
+
     let start = params
         .content_changes
         .iter()
         .rev()
         .position(|change| change.range.is_none())
         .map_or(0, |idx| params.content_changes.len() - idx - 1);
 
+    info!("Getting finalized text...");
+
     let text = apply_document_changes(
         session.position_encoding(),
         old_text,
         &params.content_changes[start..],
     );
 
+    info!("Creating new doc…");
+
     let new_doc = Document::new(version, &text);
 
+    info!("Changing File in Workspace...");
+
     session.workspace.change_file(ChangeFileParams {
         path: pglsp_path,
         version,
@@ -87,8 +99,12 @@ pub(crate) async fn did_change(
             .collect(),
     })?;
 
+    info!("Inserting document...");
+
     session.insert_document(url.clone(), new_doc);
 
+    info!("Updating diagnostics...");
+
     if let Err(err) = session.update_diagnostics(url).await {
         error!("Failed to update diagnostics: {}", err);
     }

crates/pg_lsp_new/src/main.rs

@@ -1,6 +1,7 @@
 use std::{fs::File, path::PathBuf, str::FromStr};
 
 use pg_lsp_new::ServerFactory;
+use tower_lsp::Server;
 use tracing_subscriber::fmt::format::FmtSpan;
 
 #[tokio::main]
@@ -27,10 +28,12 @@ async fn main() -> anyhow::Result<()> {
 
     tracing::info!("Starting server.");
 
-    ServerFactory::new(true)
+    ServerFactory::new(false)
         .create(Some(config_path))
         .accept(stdin, stdout)
         .await;
 
+    tracing::info!("Shut down server.");
+
     Ok(())
 }

crates/pg_lsp_new/src/server.rs

@@ -106,7 +106,7 @@ impl LSPServer {
 impl LanguageServer for LSPServer {
     #[allow(deprecated)]
     #[tracing::instrument(
-        level = "trace",
+        level = "info",
         skip_all,
         fields(
             root_uri = params.root_uri.as_ref().map(display),
@@ -143,7 +143,7 @@ impl LanguageServer for LSPServer {
         Ok(init)
     }
 
-    #[tracing::instrument(level = "trace", skip(self))]
+    #[tracing::instrument(level = "info", skip_all)]
     async fn initialized(&self, params: InitializedParams) {
         let _ = params;
 
@@ -163,19 +163,20 @@ impl LanguageServer for LSPServer {
         self.session.update_all_diagnostics().await;
     }
 
+    #[tracing::instrument(level = "info", skip(self))]
     async fn shutdown(&self) -> LspResult<()> {
         Ok(())
     }
 
-    #[tracing::instrument(level = "trace", skip(self))]
+    #[tracing::instrument(level = "info", skip(self))]
     async fn did_change_configuration(&self, params: DidChangeConfigurationParams) {
         let _ = params;
         self.session.load_workspace_settings().await;
         self.setup_capabilities().await;
         self.session.update_all_diagnostics().await;
     }
 
-    #[tracing::instrument(level = "trace", skip(self))]
+    #[tracing::instrument(level = "info", skip(self))]
     async fn did_change_watched_files(&self, params: DidChangeWatchedFilesParams) {
         let file_paths = params
             .changes
@@ -209,31 +210,35 @@ impl LanguageServer for LSPServer {
         }
     }
 
+    #[tracing::instrument(level = "info", skip(self))]
     async fn did_open(&self, params: DidOpenTextDocumentParams) {
         handlers::text_document::did_open(&self.session, params)
             .await
             .ok();
     }
 
+    #[tracing::instrument(level = "info", skip(self, params))]
     async fn did_change(&self, params: DidChangeTextDocumentParams) {
-        handlers::text_document::did_change(&self.session, params)
-            .await
-            .ok();
+        if let Err(e) = handlers::text_document::did_change(&self.session, params).await {
+            error!("{}", e);
+        };
     }
 
+    #[tracing::instrument(level = "info", skip(self))]
     async fn did_save(&self, params: DidSaveTextDocumentParams) {
         // handlers::text_document::did_save(&self.session, params)
         //     .await
         //     .ok();
     }
 
+    #[tracing::instrument(level = "info", skip(self))]
     async fn did_close(&self, params: DidCloseTextDocumentParams) {
         handlers::text_document::did_close(&self.session, params)
             .await
             .ok();
     }
 
-    #[tracing::instrument(level = "trace", skip(self))]
+    #[tracing::instrument(level = "info", skip(self))]
     async fn completion(&self, params: CompletionParams) -> LspResult<Option<CompletionResponse>> {
         match handlers::completions::get_completions(&self.session, params) {
             Ok(result) => LspResult::Ok(Some(result)),

editors/code/package-lock.json

@@ -47,7 +47,7 @@
         "anser": "^2.1.1",
         "d3": "^7.8.5",
         "d3-graphviz": "^5.0.2",
-        "vscode-languageclient": "^8.1.0"
+        "vscode-languageclient": "9.0.1"
     },
     "devDependencies": {
         "@tsconfig/strictest": "^2.0.1",

editors/code/package.json

@@ -1,4 +1,4 @@
-import type { ExtensionContext } from 'vscode';
+import { type ExtensionContext, window } from 'vscode';
 
 import {
     type Executable,
@@ -9,11 +9,11 @@ import {
 
 let client: LanguageClient;
 
-export function activate(_context: ExtensionContext) {
+export async function activate(_context: ExtensionContext) {
     // If the extension is launched in debug mode then the debug server options are used
     // Otherwise the run options are used
     const run: Executable = {
-        command: 'pglsp'
+        command: 'pglsp_new'
     };
 
     // const outputChannel = window.createOutputChannel('postgres_lsp');
@@ -26,14 +26,15 @@ export function activate(_context: ExtensionContext) {
     // Options to control the language client
     const clientOptions: LanguageClientOptions = {
         // Register the server for plain text documents
-        documentSelector: [{ scheme: 'file', language: 'sql' }]
+        documentSelector: [{ scheme: 'file', language: 'sql' }],
+        traceOutputChannel: window.createOutputChannel('Postgres LSP Tracing', { log: true })
     };
 
     // Create the language client and start the client.
     client = new LanguageClient('postgres_lsp', 'Postgres LSP', serverOptions, clientOptions);
 
     // Start the client. This will also launch the server
-    void client.start();
+    await client.start();
 }
 
 export function deactivate(): Thenable<void> | undefined {

editors/code/src/main.ts

@@ -137,7 +137,10 @@ fn install_client(sh: &Shell, client_opt: ClientOpt) -> anyhow::Result<()> {
 }
 
 fn install_server(sh: &Shell) -> anyhow::Result<()> {
-    let cmd = cmd!(sh, "cargo install --path crates/pg_lsp --locked --force");
+    let cmd = cmd!(
+        sh,
+        "cargo install --path crates/pg_lsp_new --locked --force"
+    );
     cmd.run()?;
     Ok(())
 }