Enable strict mode in the compiler, and fix all problems (#107)

package.json

@@ -55,7 +55,7 @@
         "tonsky.clojure-warrior"
     ],
     "categories": [
-        "Languages",
+        "Programming Languages",
         "Other"
     ],
     "activationEvents": [
@@ -121,6 +121,7 @@
         "@types/jszip": "^0.0.31",
         "@types/mocha": "^2.2.32",
         "@types/node": "^6.0.85",
+        "@types/cross-spawn": "^6.0.0",
         "mocha": "^2.3.3",
         "typescript": "^2.4.2",
         "vscode": "^1.0.0"

src/cljConnection.ts

@@ -11,7 +11,7 @@ export interface CljConnectionInformation {
 }
 export interface REPLSession {
     type: 'ClojureScript' | 'Clojure';
-    id: string;
+    id?: string;
 }
 
 const CONNECTION_STATE_KEY: string = 'CLJ_CONNECTION';
@@ -23,7 +23,7 @@ let cljContext: vscode.ExtensionContext;
 
 const setCljContext = (context: vscode.ExtensionContext) => cljContext = context;
 
-const getConnection = (): CljConnectionInformation => cljContext.workspaceState.get(CONNECTION_STATE_KEY);
+const getConnection = (): CljConnectionInformation | undefined => cljContext.workspaceState.get(CONNECTION_STATE_KEY);
 
 const isConnected = (): boolean => !!getConnection();
 
@@ -47,7 +47,7 @@ const saveDisconnection = (showMessage: boolean = true): void => {
         vscode.window.showInformationMessage('Disconnected from nREPL.');
 };
 
-let loadingHandler: NodeJS.Timer;
+let loadingHandler: NodeJS.Timer | null
 const startLoadingAnimation = () => {
     if (loadingHandler)
         return;
@@ -173,7 +173,11 @@ const findClojureScriptSession = (sessions: string[]): Promise<string> => {
     if (sessions.length == 0)
         return Promise.reject(null);
 
-    let base_session = sessions.shift();
+    const base_session = sessions.shift();
+
+    if (!base_session) {
+        return Promise.reject("no base session");
+    }
     return nreplClient.evaluate('(js/parseInt "42")', base_session).then(results => {
         let { session, value } = results[0];
         nreplClient.close(session);

src/cljParser.ts

@@ -22,7 +22,7 @@ const CLJ_EXPRESSION_DELIMITERS: Map<string, string> = new Map<string, string>([
     [CLJ_TEXT_DELIMITER, CLJ_TEXT_DELIMITER],
 ]);
 
-const getExpressionInfo = (text: string): ExpressionInfo => {
+const getExpressionInfo = (text: string): ExpressionInfo | undefined  => {
     text = removeCljComments(text);
     const relativeExpressionInfo = getRelativeExpressionInfo(text);
     if (!relativeExpressionInfo)
@@ -42,7 +42,7 @@ const getExpressionInfo = (text: string): ExpressionInfo => {
 };
 
 const removeCljComments = (text: string): string => {
-    const lines = text.match(/[^\r\n]+/g); // split string by line
+    const lines = text.match(/[^\r\n]+/g) || [] // split string by line
 
     if (lines.length > 1) {
         return lines.map(line => removeCljComments(line)).join(`\n`); // remove comments from each line and concat them again after
@@ -65,7 +65,7 @@ const removeCljComments = (text: string): string => {
     return line.substring(0, uncommentedIndex);
 };
 
-const getRelativeExpressionInfo = (text: string, openChar: string = `(`): RelativeExpressionInfo => {
+const getRelativeExpressionInfo = (text: string, openChar: string = `(`): RelativeExpressionInfo | undefined => {
     const relativeExpressionInfo: RelativeExpressionInfo = {
         startPosition: text.length - 1,
         parameterPosition: -1,

src/clojureConfiguration.ts

@@ -63,10 +63,10 @@ const keywords = [
     'thread',
 ]
 
-export class ClojureLanguageConfiguration implements vscode.LanguageConfiguration {
-    wordPattern = /[\w\-\.:<>\*][\w\d\.\\/\-\?<>\*!]+/;
-    indentationRules = {
-        decreaseIndentPattern: undefined,
+export const ClojureLanguageConfiguration : vscode.LanguageConfiguration = {
+    wordPattern: /[\w\-\.:<>\*][\w\d\.\\/\-\?<>\*!]+/,
+    indentationRules: {
+        decreaseIndentPattern: /$^/, // line end then start - this will never match anything
         increaseIndentPattern: /^\s*\(.*[^)]\s*$/
     }
 }

src/clojureEval.ts

@@ -19,6 +19,8 @@ function evaluate(outputChannel: vscode.OutputChannel, showResults: boolean): vo
     }
 
     const editor = vscode.window.activeTextEditor;
+
+    if (!editor) return;
     const selection = editor.selection;
     let text = editor.document.getText();
     if (!selection.isEmpty) {
@@ -65,7 +67,7 @@ function handleError(outputChannel: vscode.OutputChannel, selection: vscode.Sele
             outputChannel.appendLine(`${stacktraceObj.class} ${stacktraceObj.message}`);
             outputChannel.appendLine(` at ${stacktraceObj.file}:${errLine}:${errChar}`);
 
-            stacktraceObj.stacktrace.forEach(trace => {
+            stacktraceObj.stacktrace.forEach((trace: any) => {
                 if (trace.flags.indexOf('tooling') > -1)
                     outputChannel.appendLine(`    ${trace.class}.${trace.method} (${trace.file}:${trace.line})`);
             });

src/clojureFormat.ts

@@ -12,13 +12,13 @@ function slashEscape(contents: string) {
 }
 
 function slashUnescape(contents: string) {
-    const replacements = { '\\\\': '\\', '\\n': '\n', '\\"': '"' };
-    return contents.replace(/\\(\\|n|")/g, function (match) {
-        return replacements[match];
+    const replacements : { [key: string]: string} = { '\\\\': '\\', '\\n': '\n', '\\"': '"' };
+    return contents.replace(/\\(\\|n|")/g, function(match) {
+        return replacements[match]
     });
 }
 
-export const formatFile = (textEditor: vscode.TextEditor, edit: vscode.TextEditorEdit): void => {
+export const formatFile = (textEditor: vscode.TextEditor, edit?: vscode.TextEditorEdit): void => {
 
     if (!cljConnection.isConnected()) {
         vscode.window.showErrorMessage("Formatting functions don't work, connect to nREPL first.");
@@ -70,11 +70,14 @@ export const maybeActivateFormatOnSave = () => {
             return;
         }
         let textEditor = vscode.window.activeTextEditor;
+        if (!textEditor) {
+            return
+        }
         let editorConfig = vscode.workspace.getConfiguration('editor');
         const globalEditorFormatOnSave = editorConfig && editorConfig.has('formatOnSave') && editorConfig.get('formatOnSave') === true;
         let clojureConfig = vscode.workspace.getConfiguration('clojureVSCode');
         if ((clojureConfig.formatOnSave || globalEditorFormatOnSave) && textEditor.document === document) {
-            formatFile(textEditor, null);
+            formatFile(textEditor, undefined);
         }
     });
-}
+}

src/clojureMain.ts

@@ -20,9 +20,9 @@ export function activate(context: vscode.ExtensionContext) {
     if (config.autoStartNRepl) {
         cljConnection.startNRepl();
     }
-    
+
     maybeActivateFormatOnSave();
-    
+
     vscode.commands.registerCommand('clojureVSCode.manuallyConnectToNRepl', cljConnection.manuallyConnect);
     vscode.commands.registerCommand('clojureVSCode.stopDisconnectNRepl', cljConnection.disconnect);
     vscode.commands.registerCommand('clojureVSCode.startNRepl', cljConnection.startNRepl);
@@ -39,7 +39,7 @@ export function activate(context: vscode.ExtensionContext) {
     context.subscriptions.push(vscode.languages.registerSignatureHelpProvider(CLOJURE_MODE, new ClojureSignatureProvider(), ' ', '\n'));
 
     vscode.workspace.registerTextDocumentContentProvider('jar', new JarContentProvider());
-    vscode.languages.setLanguageConfiguration(CLOJURE_MODE.language, new ClojureLanguageConfiguration());
+    vscode.languages.setLanguageConfiguration(CLOJURE_MODE.language, ClojureLanguageConfiguration);
 }
 
 export function deactivate() { }

src/clojureMode.ts

@@ -1,3 +1,3 @@
 import vscode = require('vscode');
 
-export const CLOJURE_MODE: vscode.DocumentFilter = { language: 'clojure', scheme: 'file' };
+export const CLOJURE_MODE = { language: 'clojure', scheme: 'file' };

src/clojureSignature.ts

@@ -18,7 +18,7 @@ const SPECIAL_FORM_CUSTOM_ARGLISTS: Map<string, string> = new Map<string, string
 
 export class ClojureSignatureProvider implements vscode.SignatureHelpProvider {
 
-    provideSignatureHelp(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken): Thenable<vscode.SignatureHelp> {
+    provideSignatureHelp(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken): vscode.ProviderResult<vscode.SignatureHelp> {
         if (!cljConnection.isConnected())
             return Promise.reject('No nREPL connected.');
 
@@ -55,7 +55,7 @@ function getSpecialFormSignatureHelp(info: any, parameterPosition: number): vsco
     return getSignatureHelp(signatureLabel, info.doc, arglists, parameterPosition);
 }
 
-function getFunctionSignatureHelp(info: any, parameterPosition: number): vscode.SignatureHelp {
+function getFunctionSignatureHelp(info: any, parameterPosition: number): vscode.SignatureHelp | undefined {
     const arglists = info['arglists-str'];
     if (!arglists)
         return;

src/clojureSuggest.ts

@@ -3,17 +3,19 @@ import { cljConnection } from './cljConnection';
 import { cljParser } from './cljParser';
 import { nreplClient } from './nreplClient';
 
-const mappings = {
-    'nil': vscode.CompletionItemKind.Value,
-    'macro': vscode.CompletionItemKind.Value,
-    'class': vscode.CompletionItemKind.Class,
-    'keyword': vscode.CompletionItemKind.Keyword,
-    'namespace': vscode.CompletionItemKind.Module,
-    'function': vscode.CompletionItemKind.Function,
-    'special-form': vscode.CompletionItemKind.Keyword,
-    'var': vscode.CompletionItemKind.Variable,
-    'method': vscode.CompletionItemKind.Method,
-}
+const mappings: {
+    [key: string]: vscode.CompletionItemKind
+} = {
+        'nil': vscode.CompletionItemKind.Value,
+        'macro': vscode.CompletionItemKind.Value,
+        'class': vscode.CompletionItemKind.Class,
+        'keyword': vscode.CompletionItemKind.Keyword,
+        'namespace': vscode.CompletionItemKind.Module,
+        'function': vscode.CompletionItemKind.Function,
+        'special-form': vscode.CompletionItemKind.Keyword,
+        'var': vscode.CompletionItemKind.Variable,
+        'method': vscode.CompletionItemKind.Method,
+    }
 
 export class ClojureCompletionItemProvider implements vscode.CompletionItemProvider {
 
@@ -38,7 +40,7 @@ export class ClojureCompletionItemProvider implements vscode.CompletionItemProvi
             if (!('completions' in completions))
                 return Promise.reject(undefined);
 
-            let suggestions = completions.completions.map(element => ({
+            let suggestions = completions.completions.map((element: any) => ({
                 label: element.candidate,
                 kind: mappings[element.type] || vscode.CompletionItemKind.Text,
                 insertText: buildInsertText(element.candidate)
@@ -49,7 +51,11 @@ export class ClojureCompletionItemProvider implements vscode.CompletionItemProvi
     }
 
     public resolveCompletionItem(item: vscode.CompletionItem, token: vscode.CancellationToken): Thenable<vscode.CompletionItem> {
-        let document = vscode.window.activeTextEditor.document;
+        const editor = vscode.window.activeTextEditor
+        if (!editor) {
+            return Promise.reject("No active editor");
+        }
+        let document = editor.document;
         let ns = cljParser.getNamespace(document.getText());
         return nreplClient.info(item.label, ns).then(info => {
             item.documentation = info.doc;

src/nreplClient.ts

@@ -15,7 +15,7 @@ interface nREPLInfoMessage {
     op: string;
     symbol: string;
     ns: string;
-    session: string;
+    session?: string;
 }
 
 interface nREPLEvalMessage {
@@ -56,28 +56,31 @@ const info = (symbol: string, ns: string, session?: string): Promise<any> => {
     return send(msg).then(respObjs => respObjs[0]);
 };
 
-const evaluate = (code: string, session?: string): Promise<any[]> => clone(session).then((new_session) => {
-    const session_id = new_session['new-session'];
+const evaluate = (code: string, session?: string): Promise<any[]> => clone(session).then((session_id) => {
     const msg: nREPLSingleEvalMessage = { op: 'eval', code: code, session: session_id };
     return send(msg);
 });
 
-const evaluateFile = (code: string, filepath: string, session?: string): Promise<any[]> => clone(session).then((new_session) => {
-    const session_id = new_session['new-session'];
+const evaluateFile = (code: string, filepath: string, session?: string): Promise<any[]> => clone(session).then((session_id) => {
     const msg: nREPLEvalMessage = { op: 'load-file', file: code, 'file-path': filepath, session: session_id };
     return send(msg);
 });
 
 const stacktrace = (session: string): Promise<any> => send({ op: 'stacktrace', session: session });
 
-const clone = (session?: string): Promise<any[]> => send({ op: 'clone', session: session }).then(respObjs => respObjs[0]);
+const clone = (session?: string): Promise<string> => {
+    return send({ op: 'clone', session: session }).then(respObjs => respObjs[0]['new-session']);
+}
 
 const test = (connectionInfo: CljConnectionInformation): Promise<any[]> => {
     return send({ op: 'clone' }, connectionInfo)
         .then(respObjs => respObjs[0])
         .then(response => {
             if (!('new-session' in response))
                 return Promise.reject(false);
+            else {
+                return Promise.resolve([]);
+            }
         });
 };
 
@@ -100,21 +103,21 @@ const send = (msg: nREPLCompleteMessage | nREPLInfoMessage | nREPLEvalMessage |
             return reject('No connection found.');
 
         const client = net.createConnection(connection.port, connection.host);
-        Object.keys(msg).forEach(key => msg[key] === undefined && delete msg[key]);
+        Object.keys(msg).forEach(key => (msg as any)[key] === undefined && delete (msg as any)[key]);
         client.write(bencodeUtil.encode(msg), 'binary');
 
         client.on('error', error => {
             client.end();
             client.removeAllListeners();
-            if (error['code'] == 'ECONNREFUSED') {
+            if ((error as any)['code'] === 'ECONNREFUSED') {
                 vscode.window.showErrorMessage('Connection refused.');
                 cljConnection.disconnect();
             }
             reject(error);
         });
 
         let nreplResp = Buffer.from('');
-        const respObjects = [];
+        const respObjects: any[] = [];
         client.on('data', data => {
             nreplResp = Buffer.concat([nreplResp, data]);
             const { decodedObjects, rest } = bencodeUtil.decodeObjects(nreplResp);

src/nreplController.ts

@@ -1,7 +1,7 @@
 import 'process';
 import * as os from 'os';
 import * as vscode from 'vscode';
-import { spawn } from 'cross-spawn';
+import * as spawn from 'cross-spawn';
 import { ChildProcess, exec } from 'child_process';
 
 import { CljConnectionInformation } from './cljConnection';
@@ -28,7 +28,7 @@ const LEIN_ARGS: string[] = [
 
 const R_NREPL_CONNECTION_INFO = /nrepl:\/\/(.*?:.*?(?=[\n\r]))/;
 
-let nreplProcess: ChildProcess;
+let nreplProcess: ChildProcess | null
 
 const isStarted = () => !!nreplProcess;
 
@@ -40,16 +40,17 @@ const start = (): Promise<CljConnectionInformation> => {
     if (isStarted())
         return Promise.reject({ nreplError: 'nREPL already started.' });
 
-    nreplProcess = spawn('lein', LEIN_ARGS, {
-        cwd: vscode.workspace.rootPath,
-        detached: !(os.platform() === 'win32')
-    });
-
     // Clear any output from previous nREPL sessions to help users focus
     // on the current session only.
     nreplChannel.clear();
 
     return new Promise((resolve, reject) => {
+
+        nreplProcess = spawn('lein', LEIN_ARGS, {
+            cwd: vscode.workspace.rootPath,
+            detached: !(os.platform() === 'win32')
+        });
+
         nreplProcess.stdout.addListener('data', data => {
             const nreplConnectionMatch = data.toString().match(R_NREPL_CONNECTION_INFO);
             // Send any stdout messages to the output channel