Enable "strict" compiler option (clangd#178)

* Enable "strict" compiler option

* Address comments and change double-equals to triple-equals

* Modify open-config.ts to adhere to strict type checking

Author: BigBahss

src/ast.ts

@@ -39,11 +39,13 @@ class ASTFeature implements vscodelc.StaticFeature {
         // clangd.ast.hasData controls the view visibility (package.json).
         adapter.onDidChangeTreeData((_) => {
           vscode.commands.executeCommand('setContext', 'clangd.ast.hasData',
-                                         adapter.hasRoot())
-          // Show the AST tree even if it's beet collapsed or closed.
+                                         adapter.hasRoot());
+          // Work around https://github.com/microsoft/vscode/issues/90005
+          // Show the AST tree even if it's been collapsed or closed.
           // reveal(root) fails here: "Data tree node not found".
           if (adapter.hasRoot())
-          tree.reveal(null);
+            // @ts-ignore
+            tree.reveal(null);
         }),
         vscode.window.registerTreeDataProvider('clangd.ast', adapter),
         // Create the "Show AST" command for the context menu.
@@ -61,12 +63,12 @@ class ASTFeature implements vscodelc.StaticFeature {
               if (!item)
                 vscode.window.showInformationMessage(
                     'No AST node at selection');
-              adapter.setRoot(item, editor.document.uri);
+              adapter.setRoot(item ?? undefined, editor.document.uri);
             }),
         // Clicking "close" will empty the adapter, which in turn hides the
         // view.
-        vscode.commands.registerCommand('clangd.ast.close',
-                                        () => adapter.setRoot(null, null)));
+        vscode.commands.registerCommand(
+            'clangd.ast.close', () => adapter.setRoot(undefined, undefined)));
   }
 
   fillClientCapabilities(capabilities: vscodelc.ClientCapabilities) {}
@@ -109,8 +111,8 @@ const KindIcons: {[type: string]: string} = {
 function describe(role: string, kind: string): string {
   // For common roles where the kind is fairly self-explanatory, we don't
   // include it. e.g. "Call" rather than "Call expression".
-  if (role == 'expression' || role == 'statement' || role == 'declaration' ||
-      role == 'template name')
+  if (role === 'expression' || role === 'statement' || role === 'declaration' ||
+      role === 'template name')
     return kind;
   return kind + ' ' + role;
 }
@@ -120,9 +122,9 @@ class TreeAdapter implements vscode.TreeDataProvider<ASTNode> {
   private root?: ASTNode;
   private doc?: vscode.Uri;
 
-  hasRoot(): boolean { return this.root != null; }
+  hasRoot(): boolean { return this.root !== undefined; }
 
-  setRoot(newRoot: ASTNode|null, newDoc: vscode.Uri|null) {
+  setRoot(newRoot: ASTNode|undefined, newDoc: vscode.Uri|undefined) {
     this.root = newRoot;
     this.doc = newDoc;
     this._onDidChangeTreeData.fire(/*root changed*/ null);
@@ -163,16 +165,16 @@ class TreeAdapter implements vscode.TreeDataProvider<ASTNode> {
     return element.children || [];
   }
 
-  public getParent(node: ASTNode): ASTNode {
-    if (node == this.root)
-      return null;
-    function findUnder(parent: ASTNode): ASTNode|null {
-      for (const child of parent.children || []) {
-        const result = (node == child) ? parent : findUnder(child);
+  public getParent(node: ASTNode): ASTNode|undefined {
+    if (node === this.root)
+      return undefined;
+    function findUnder(parent: ASTNode|undefined): ASTNode|undefined {
+      for (const child of parent?.children ?? []) {
+        const result = (node === child) ? parent : findUnder(child);
         if (result)
           return result;
       }
-      return null;
+      return undefined;
     }
     return findUnder(this.root);
   }

src/clangd-context.ts

@@ -36,15 +36,15 @@ class EnableEditsNearCursorFeature implements vscodelc.StaticFeature {
   initialize() {}
   fillClientCapabilities(capabilities: vscodelc.ClientCapabilities): void {
     const extendedCompletionCapabilities: any =
-        capabilities.textDocument.completion;
+        capabilities.textDocument?.completion;
     extendedCompletionCapabilities.editsNearCursor = true;
   }
   dispose() {}
 }
 
 export class ClangdContext implements vscode.Disposable {
   subscriptions: vscode.Disposable[] = [];
-  client: ClangdLanguageClient;
+  client!: ClangdLanguageClient;
 
   async activate(globalStoragePath: string, outputChannel: vscode.OutputChannel,
                  workspaceState: vscode.Memento) {
@@ -104,7 +104,7 @@ export class ClangdContext implements vscode.Disposable {
           let list = await next(document, position, context, token);
           if (!config.get<boolean>('serverCompletionRanking'))
             return list;
-          let items = (Array.isArray(list) ? list : list.items).map(item => {
+          let items = (Array.isArray(list) ? list : list!.items).map(item => {
             // Gets the prefix used by VSCode when doing fuzzymatch.
             let prefix = document.getText(
                 new vscode.Range((item.range as vscode.Range).start, position))
@@ -121,7 +121,7 @@ export class ClangdContext implements vscode.Disposable {
         // qualified symbols.
         provideWorkspaceSymbols: async (query, token, next) => {
           let symbols = await next(query, token);
-          return symbols.map(symbol => {
+          return symbols?.map(symbol => {
             // Only make this adjustment if the query is in fact qualified.
             // Otherwise, we get a suboptimal ordering of results because
             // including the name's qualifier (if it has one) in symbol.name

src/config-file-watcher.ts

@@ -5,7 +5,7 @@ import {ClangdContext} from './clangd-context';
 import * as config from './config';
 
 export function activate(context: ClangdContext) {
-  if (config.get<string>('onConfigChanged') != 'ignore') {
+  if (config.get<string>('onConfigChanged') !== 'ignore') {
     context.client.registerFeature(new ConfigFileWatcherFeature(context));
   }
 }
@@ -30,8 +30,8 @@ class ConfigFileWatcherFeature implements vscodelc.StaticFeature {
 }
 
 class ConfigFileWatcher implements vscode.Disposable {
-  private databaseWatcher: vscode.FileSystemWatcher = undefined;
-  private debounceTimer: NodeJS.Timer = undefined;
+  private databaseWatcher?: vscode.FileSystemWatcher;
+  private debounceTimer?: NodeJS.Timer;
 
   dispose() {
     if (this.databaseWatcher)

src/config.ts

@@ -3,7 +3,7 @@ import * as vscode from 'vscode';
 
 // Gets the config value `clangd.<key>`. Applies ${variable} substitutions.
 export function get<T>(key: string): T {
-  return substitute(vscode.workspace.getConfiguration('clangd').get(key));
+  return substitute(vscode.workspace.getConfiguration('clangd').get<T>(key)!);
 }
 
 // Like get(), but won't load settings from workspace config unless the user has
@@ -21,11 +21,11 @@ export async function getSecureOrPrompt<T>(
   const prop = new SecureProperty<T>(key, workspaceState);
   // Common case: value not overridden in workspace.
   if (!prop.mismatched)
-    return prop.get(false);
+    return prop.get(false)!;
   // Check whether user has blessed or blocked this value.
   const blessed = prop.blessed;
-  if (blessed !== null)
-    return prop.get(blessed);
+  if (blessed !== undefined)
+    return prop.get(blessed)!;
   // No cached decision for this value, ask the user.
   const Yes = 'Yes, use this setting', No = 'No, use my default',
         Info = 'More Info'
@@ -40,11 +40,11 @@ export async function getSecureOrPrompt<T>(
     break;
   case Yes:
     await prop.bless(true);
-    return prop.get(true);
+    return prop.get(true)!;
   case No:
     await prop.bless(false);
   }
-  return prop.get(false);
+  return prop.get(false)!;
 }
 
 // Sets the config value `clangd.<key>`. Does not apply substitutions.
@@ -55,15 +55,14 @@ export function update<T>(key: string, value: T,
 
 // Traverse a JSON value, replacing placeholders in all strings.
 function substitute<T>(val: T): T {
-  if (typeof val == 'string') {
+  if (typeof val === 'string') {
     val = val.replace(/\$\{(.*?)\}/g, (match, name) => {
-      const rep = replacement(name);
       // If there's no replacement available, keep the placeholder.
-      return (rep === null) ? match : rep;
+      return replacement(name) ?? match;
     }) as unknown as T;
   } else if (Array.isArray(val))
     val = val.map((x) => substitute(x)) as unknown as T;
-  else if (typeof val == 'object') {
+  else if (typeof val === 'object') {
     // Substitute values but not keys, so we don't deal with collisions.
     const result = {} as {[k: string]: any};
     for (let [k, v] of Object.entries(val))
@@ -75,8 +74,9 @@ function substitute<T>(val: T): T {
 
 // Subset of substitution variables that are most likely to be useful.
 // https://code.visualstudio.com/docs/editor/variables-reference
-function replacement(name: string): string|null {
-  if (name == 'workspaceRoot' || name == 'workspaceFolder' || name == 'cwd') {
+function replacement(name: string): string|undefined {
+  if (name === 'workspaceRoot' || name === 'workspaceFolder' ||
+      name === 'cwd') {
     if (vscode.workspace.rootPath !== undefined)
       return vscode.workspace.rootPath;
     if (vscode.window.activeTextEditor !== undefined)
@@ -85,15 +85,15 @@ function replacement(name: string): string|null {
   }
   const envPrefix = 'env:';
   if (name.startsWith(envPrefix))
-    return process.env[name.substr(envPrefix.length)] || '';
+    return process.env[name.substr(envPrefix.length)] ?? '';
   const configPrefix = 'config:';
   if (name.startsWith(configPrefix)) {
     const config = vscode.workspace.getConfiguration().get(
         name.substr(configPrefix.length));
-    return (typeof config == 'string') ? config : null;
+    return (typeof config === 'string') ? config : undefined;
   }
 
-  return null;
+  return undefined;
 }
 
 // Caches a user's decision about whether to respect a workspace override of a
@@ -106,32 +106,32 @@ interface BlessCache {
 
 // Common logic between getSecure and getSecureOrPrompt.
 class SecureProperty<T> {
-  secure: T|undefined;
-  insecure: T|undefined;
+  secure?: T;
+  insecure?: T;
   public secureJSON: string;
   public insecureJSON: string;
   blessKey: string;
 
   constructor(key: string, private workspaceState: vscode.Memento) {
     const cfg = vscode.workspace.getConfiguration('clangd');
-    const inspect = cfg.inspect<T>(key);
+    const inspect = cfg.inspect<T>(key)!;
     this.secure = inspect.globalValue ?? inspect.defaultValue;
     this.insecure = cfg.get<T>(key);
     this.secureJSON = JSON.stringify(this.secure);
     this.insecureJSON = JSON.stringify(this.insecure);
     this.blessKey = 'bless.' + key;
   }
 
-  get mismatched(): boolean { return this.secureJSON != this.insecureJSON; }
+  get mismatched(): boolean { return this.secureJSON !== this.insecureJSON; }
 
   get(trusted: boolean): T|undefined {
     return substitute(trusted ? this.insecure : this.secure);
   }
 
-  get blessed(): boolean|null {
+  get blessed(): boolean|undefined {
     let cache = this.workspaceState.get<BlessCache>(this.blessKey);
-    if (!cache || cache.json != this.insecureJSON)
-      return null;
+    if (!cache || cache.json !== this.insecureJSON)
+      return undefined;
     return cache.allowed;
   }
 

src/file-status.ts

@@ -11,12 +11,12 @@ export function activate(context: ClangdContext) {
   context.subscriptions.push(vscode.window.onDidChangeActiveTextEditor(
       () => { status.updateStatus(); }));
   context.subscriptions.push(context.client.onDidChangeState(({newState}) => {
-    if (newState == vscodelc.State.Running) {
+    if (newState === vscodelc.State.Running) {
       // clangd starts or restarts after crash.
       context.client.onNotification(
           'textDocument/clangd.fileStatus',
           (fileStatus) => { status.onFileUpdated(fileStatus); });
-    } else if (newState == vscodelc.State.Stopped) {
+    } else if (newState === vscodelc.State.Stopped) {
       // Clear all cached statuses when clangd crashes.
       status.clear();
     }
@@ -39,11 +39,11 @@ class FileStatus {
   }
 
   updateStatus() {
-    const activeDoc = vscode.window.activeTextEditor.document;
+    const activeDoc = vscode.window.activeTextEditor?.document;
     // Work around https://github.com/microsoft/vscode/issues/58869
     // Don't hide the status when activeTextEditor is output panel.
     // This aligns with the behavior of other panels, e.g. problems.
-    if (activeDoc.uri.scheme == 'output')
+    if (!activeDoc || activeDoc.uri.scheme === 'output')
       return;
     const status = this.statuses.get(activeDoc.fileName);
     if (!status) {

src/install.ts

@@ -12,7 +12,7 @@ import * as config from './config';
 // Returns the clangd path to be used, or null if clangd is not installed.
 export async function activate(
     context: ClangdContext, globalStoragePath: string,
-    workspaceState: vscode.Memento): Promise<string> {
+    workspaceState: vscode.Memento): Promise<string|null> {
   // If the workspace overrides clangd.path, give the user a chance to bless it.
   await config.getSecureOrPrompt<string>('path', workspaceState);
 
@@ -46,7 +46,7 @@ class UI {
     const opts = {
       location: vscode.ProgressLocation.Notification,
       title: title,
-      cancellable: cancel != null,
+      cancellable: cancel !== null,
     };
     const result = vscode.window.withProgress(opts, async (progress, canc) => {
       if (cancel)
@@ -68,16 +68,16 @@ class UI {
         vscode.commands.registerCommand(name, body));
   }
 
-  async shouldReuse(release: string): Promise<boolean> {
+  async shouldReuse(release: string): Promise<boolean|undefined> {
     const message = `clangd ${release} is already installed!`;
     const use = 'Use the installed version';
     const reinstall = 'Delete it and reinstall';
     const response =
         await vscode.window.showInformationMessage(message, use, reinstall);
-    if (response == use) {
+    if (response === use) {
       // Find clangd within the existing directory.
       return true;
-    } else if (response == reinstall) {
+    } else if (response === reinstall) {
       // Remove the existing installation.
       return false;
     } else {
@@ -103,11 +103,10 @@ class UI {
     const update = `Install clangd ${newVersion}`;
     const dontCheck = 'Don\'t ask again';
     const response =
-        await vscode.window.showInformationMessage(message, update, dontCheck)
-    if (response == update) {
+        await vscode.window.showInformationMessage(message, update, dontCheck);
+    if (response === update) {
       common.installLatest(this);
-    }
-    else if (response == dontCheck) {
+    } else if (response === dontCheck) {
       config.update('checkUpdates', false, vscode.ConfigurationTarget.Global);
     }
   }
@@ -126,10 +125,10 @@ class UI {
   }
 
   get clangdPath(): string {
-    let p = config.getSecure<string>('path', this.workspaceState);
+    let p = config.getSecure<string>('path', this.workspaceState)!;
     // Backwards compatibility: if it's a relative path with a slash, interpret
     // relative to project root.
-    if (!path.isAbsolute(p) && p.indexOf(path.sep) != -1 &&
+    if (!path.isAbsolute(p) && p.includes(path.sep) &&
         vscode.workspace.rootPath !== undefined)
       p = path.join(vscode.workspace.rootPath, p);
     return p;

src/memory-usage.ts

@@ -51,9 +51,9 @@ function convert(m: WireTree, title: string): InternalTree {
 class MemoryUsageFeature implements vscodelc.StaticFeature {
   constructor(private context: ClangdContext) {
     const adapter = new TreeAdapter();
-    adapter.onDidChangeTreeData(
-        (e) => vscode.commands.executeCommand(
-            'setContext', 'clangd.memoryUsage.hasData', adapter.root != null));
+    adapter.onDidChangeTreeData((e) => vscode.commands.executeCommand(
+                                    'setContext', 'clangd.memoryUsage.hasData',
+                                    adapter.root !== undefined));
     this.context.subscriptions.push(
         vscode.window.registerTreeDataProvider('clangd.memoryUsage', adapter));
     this.context.subscriptions.push(
@@ -63,7 +63,7 @@ class MemoryUsageFeature implements vscodelc.StaticFeature {
           adapter.root = convert(usage, '<root>');
         }));
     this.context.subscriptions.push(vscode.commands.registerCommand(
-        'clangd.memoryUsage.close', () => adapter.root = null));
+        'clangd.memoryUsage.close', () => adapter.root = undefined));
   }
 
   fillClientCapabilities(capabilities: vscodelc.ClientCapabilities) {}
@@ -80,8 +80,8 @@ class MemoryUsageFeature implements vscodelc.StaticFeature {
 class TreeAdapter implements vscode.TreeDataProvider<InternalTree> {
   private root_?: InternalTree;
 
-  get root(): InternalTree|null { return this.root_; }
-  set root(n: InternalTree|null) {
+  get root(): InternalTree|undefined { return this.root_; }
+  set root(n: InternalTree|undefined) {
     this.root_ = n;
     this._onDidChangeTreeData.fire(/*root changed*/ null);
   }