#22: Refactor variable names for clarity and consistency.

Author: yegor256

src/server.ts

@@ -44,27 +44,27 @@ const documents: TextDocuments<TextDocument> = new TextDocuments(TextDocument);
 /**
  * Client capabilities manager, to define what is and is not able to do.
  */
-const clientCapabilities = new Capabilities();
+const capabilities = new Capabilities();
 
 /**
  * Provider of the semantic highlighting capability of the language server.
  */
-let semanticTokensProvider: SemanticTokensProvider;
+let provider: SemanticTokensProvider;
 
 /**
  * Defines procedures to be executed on the initialization process
  * of the connection with the client
  */
 connection.onInitialize((params: InitializeParams) => {
-    const capabilities = params.capabilities;
-    clientCapabilities.initialize(capabilities);
-    semanticTokensProvider = new SemanticTokensProvider(params.capabilities.textDocument!.semanticTokens!);
+    const caps = params.capabilities;
+    capabilities.initialize(caps);
+    provider = new SemanticTokensProvider(params.capabilities.textDocument!.semanticTokens!);
     const result: InitializeResult = {
         capabilities: {
             textDocumentSync: TextDocumentSyncKind.Incremental
         }
     };
-    if (clientCapabilities.workspace) {
+    if (capabilities.workspace) {
         result.capabilities.workspace = {
             workspaceFolders: {
                 supported: true
@@ -82,24 +82,24 @@ connection.onInitialize((params: InitializeParams) => {
  * Configuration, Workspace Folder and Document Semantic Tokens
  */
 connection.onInitialized(() => {
-    if (clientCapabilities.configuration) {
+    if (capabilities.configuration) {
         connection.client.register(DidChangeConfigurationNotification.type, void 0);
     }
-    if (clientCapabilities.workspace) {
+    if (capabilities.workspace) {
         connection.workspace.onDidChangeWorkspaceFolders(_event => {
             connection.console.log("Workspace folder change event received");
         });
     }
-    if (clientCapabilities.tokens) {
-        const registrationOptions: SemanticTokensRegistrationOptions = {
+    if (capabilities.tokens) {
+        const options: SemanticTokensRegistrationOptions = {
             documentSelector: null,
-            legend: semanticTokensProvider.legend,
+            legend: provider.legend,
             range: false,
             full: {
                 delta: true
             }
         };
-        connection.client.register(SemanticTokensRegistrationType.type, registrationOptions);
+        connection.client.register(SemanticTokensRegistrationType.type, options);
     }
 });
 
@@ -111,29 +111,29 @@ const defaultSettings: DefaultSettings = { limit: 1000 };
 /**
  * The global settings, used when the `workspace/configuration` request is not supported by the client.
  */
-let globalSettings: DefaultSettings = defaultSettings;
+let settings: DefaultSettings = defaultSettings;
 
 /**
  * Cache for the settings of all open documents
  */
-const documentSettings: Map<string, Thenable<DefaultSettings>> = new Map();
+const cache: Map<string, Thenable<DefaultSettings>> = new Map();
 
 /**
  * Retrieves the settings for a document
  * @param resource - String for the scheme of the document for which to retrieve its settings
  * @returns - A Promise for the settings of the document requested
  */
 function getDocumentSettings(resource: string): Thenable<DefaultSettings> {
-    if (!clientCapabilities.configuration) {
-        return Promise.resolve(globalSettings);
+    if (!capabilities.configuration) {
+        return Promise.resolve(settings);
     }
-    let result = documentSettings.get(resource);
+    let result = cache.get(resource);
     if (!result) {
         result = connection.workspace.getConfiguration({
             scopeUri: resource,
             section: "languageServerExample"
-        });
-        documentSettings.set(resource, result);
+        }).then(config => (config && typeof config === "object") ? config : defaultSettings);
+        cache.set(resource, result);
     }
     return result;
 }
@@ -145,13 +145,15 @@ function getDocumentSettings(resource: string): Thenable<DefaultSettings> {
  * @param textDocument - Document for which to perform the validation procedure
  * @returns {Promise<void>}
  */
-async function validateTextDocument(textDocument: TextDocument): Promise<void> {
-    const settings = await getDocumentSettings(textDocument.uri);
-    const text = textDocument.getText();
+async function validateTextDocument(document: TextDocument): Promise<void> {
+    const config = await getDocumentSettings(document.uri);
+    const text = document.getText();
     const diagnostics: Diagnostic[] = [];
     const errors = getParserErrors(text);
+    const effective = config || defaultSettings;
+    const limit = effective.limit;
     errors.forEach((error, index) => {
-        if (settings?.limit !== null && index >= settings.limit) {
+        if (limit !== null && index >= limit) {
             return;
         }
         const diagnostic: Diagnostic = {
@@ -165,20 +167,19 @@ async function validateTextDocument(textDocument: TextDocument): Promise<void> {
         };
         diagnostics.push(diagnostic);
     });
-    connection.sendDiagnostics({ uri: textDocument.uri, diagnostics });
+    connection.sendDiagnostics({ uri: document.uri, diagnostics });
 }
 
 /**
  * Resets all cached document settings and revalidates all open text
  * documents with there is a change in the configuration of the client.
  */
 connection.onDidChangeConfiguration(change => {
-    if (clientCapabilities.configuration) {
-        documentSettings.clear();
+    if (capabilities.configuration) {
+        cache.clear();
     } else {
-        globalSettings = <DefaultSettings>(
-            (change.settings.languageServerExample || defaultSettings)
-        );
+        const config = change.settings.languageServerExample;
+        settings = (config && typeof config === "object") ? config : defaultSettings;
     }
     documents.all().forEach(validateTextDocument);
 });
@@ -187,7 +188,7 @@ connection.onDidChangeConfiguration(change => {
  * Clears the settings cache for a closed document, once it is closed
  */
 documents.onDidClose(e => {
-    documentSettings.delete(e.document.uri);
+    cache.delete(e.document.uri);
 });
 
 /**
@@ -214,7 +215,7 @@ connection.languages.semanticTokens.on(params => {
     if (!document) {
         return { data: [] };
     }
-    return semanticTokensProvider.provideSemanticTokens(document);
+    return provider.provideSemanticTokens(document);
 });
 
 /**
@@ -226,7 +227,7 @@ connection.languages.semanticTokens.onDelta(params => {
     if (!document) {
         return { data: [] };
     }
-    return semanticTokensProvider.provideDeltas(document);
+    return provider.provideDeltas(document);
 });
 
 /**

src/test/integration.test.ts

@@ -10,33 +10,33 @@ import * as fs from "fs";
  */
 describe("LSP Server Integration", () => {
     let server: ChildProcess;
-    let messageHandlers: Map<number, (response: any) => void> = new Map();
-    let notificationHandlers: ((notification: any) => void)[] = [];
-    let messageId = 0;
+    let handlers: Map<number, (response: any) => void> = new Map();
+    let notifications: ((notification: any) => void)[] = [];
+    let id = 0;
     let buffer = Buffer.alloc(0);
 
     /**
      * Sends a request to the LSP server
      */
     function sendRequest(method: string, params: any): Promise<any> {
         return new Promise((resolve, reject) => {
-            const id = ++messageId;
+            const current = ++id;
             const request = {
                 jsonrpc: "2.0",
-                id: id,
+                id: current,
                 method: method,
                 params: params
             };
             const content = JSON.stringify(request);
             const header = `Content-Length: ${Buffer.byteLength(content)}\r\n\r\n`;
             const message = header + content;
             const timeout = setTimeout(() => {
-                messageHandlers.delete(id);
+                handlers.delete(current);
                 reject(new Error(`Request ${method} timed out`));
             }, 10000);
-            messageHandlers.set(id, (response) => {
+            handlers.set(current, (response) => {
                 clearTimeout(timeout);
-                messageHandlers.delete(id);
+                handlers.delete(current);
                 if (response.error) {
                     reject(new Error(response.error.message));
                 } else {
@@ -85,10 +85,10 @@ describe("LSP Server Integration", () => {
 
             try {
                 const message = JSON.parse(content);
-                if (message.id !== undefined && messageHandlers.has(message.id)) {
-                    messageHandlers.get(message.id)!(message);
+                if (message.id !== undefined && handlers.has(message.id)) {
+                    handlers.get(message.id)!(message);
                 } else if (message.method) {
-                    notificationHandlers.forEach(handler => handler(message));
+                    notifications.forEach(handler => handler(message));
                 }
             } catch (e) {
                 console.error("Failed to parse message:", e);
@@ -97,8 +97,8 @@ describe("LSP Server Integration", () => {
     }
 
     beforeEach((done) => {
-        messageHandlers.clear();
-        notificationHandlers = [];
+        handlers.clear();
+        notifications = [];
         buffer = Buffer.alloc(0);
         const serverPath = path.join(__dirname, "..", "..", "out", "server.js");
 
@@ -204,11 +204,11 @@ describe("LSP Server Integration", () => {
             const handler = (message: any) => {
                 if (message.method === "textDocument/publishDiagnostics" &&
                     message.params.uri === uri) {
-                    notificationHandlers = notificationHandlers.filter(h => h !== handler);
+                    notifications = notifications.filter(h => h !== handler);
                     resolve(message.params.diagnostics);
                 }
             };
-            notificationHandlers.push(handler);
+            notifications.push(handler);
         });
         sendNotification("textDocument/didOpen", {
             textDocument: {
@@ -254,11 +254,11 @@ describe("LSP Server Integration", () => {
                 if (message.method === "textDocument/publishDiagnostics" &&
                     message.params.uri === uri &&
                     message.params.diagnostics.length > 0) {
-                    notificationHandlers = notificationHandlers.filter(h => h !== handler);
+                    notifications = notifications.filter(h => h !== handler);
                     resolve(message.params.diagnostics);
                 }
             };
-            notificationHandlers.push(handler);
+            notifications.push(handler);
         });
 
         sendNotification("textDocument/didChange", {
@@ -275,4 +275,105 @@ describe("LSP Server Integration", () => {
         expect(Array.isArray(diagnostics)).toBeTruthy();
         expect((diagnostics as any[]).length).toBeGreaterThan(0);
     }, 15000);
+
+    test("Server handles null settings during validation without crashing", async () => {
+        await sendRequest("initialize", {
+            processId: process.pid,
+            rootUri: null,
+            capabilities: {
+                workspace: {
+                    configuration: false
+                },
+                textDocument: {
+                    semanticTokens: {
+                        tokenTypes: [],
+                        tokenModifiers: []
+                    }
+                }
+            }
+        });
+        sendNotification("initialized", {});
+        const uri = "file:///nullsettings.eo";
+        const content = "-- invalid syntax to trigger validation --\n".repeat(1100);
+
+        const diagnosticsPromise = new Promise((resolve) => {
+            const handler = (message: any) => {
+                if (message.method === "textDocument/publishDiagnostics" &&
+                    message.params.uri === uri) {
+                    notifications = notifications.filter(h => h !== handler);
+                    resolve(message.params.diagnostics);
+                }
+            };
+            notifications.push(handler);
+        });
+
+        sendNotification("textDocument/didOpen", {
+            textDocument: {
+                uri: uri,
+                languageId: "eo",
+                version: 1,
+                text: content
+            }
+        });
+
+        const diagnostics = await diagnosticsPromise;
+        expect(Array.isArray(diagnostics)).toBeTruthy();
+    }, 15000);
+
+    test("Server handles malformed workspace configuration without crashing", async () => {
+        await sendRequest("initialize", {
+            processId: process.pid,
+            rootUri: null,
+            capabilities: {
+                workspace: {
+                    configuration: true
+                },
+                textDocument: {
+                    semanticTokens: {
+                        tokenTypes: [],
+                        tokenModifiers: []
+                    }
+                }
+            }
+        });
+        sendNotification("initialized", {});
+
+        sendNotification("workspace/didChangeConfiguration", {
+            settings: {
+                languageServerExample: null
+            }
+        });
+
+        const uri = "file:///malformed.eo";
+        const content = "-- invalid syntax --";
+
+        const diagnosticsPromise = new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                notifications = notifications.filter(h => h !== handler);
+                resolve([]);
+            }, 5000);
+            
+            const handler = (message: any) => {
+                if (message.method === "textDocument/publishDiagnostics" &&
+                    message.params.uri === uri) {
+                    clearTimeout(timeout);
+                    notifications = notifications.filter(h => h !== handler);
+                    resolve(message.params.diagnostics);
+                }
+            };
+            notifications.push(handler);
+        });
+
+        sendNotification("textDocument/didOpen", {
+            textDocument: {
+                uri: uri,
+                languageId: "eo",
+                version: 1,
+                text: content
+            }
+        });
+
+        const diagnostics = await diagnosticsPromise;
+        expect(Array.isArray(diagnostics)).toBeTruthy();
+    }, 15000);
 });