Remove unneeded promise constructors

Signed-off-by: Josh Pinkney <joshpinkney@gmail.com>

Author: JPinkney

src/languageservice/services/yamlCompletion.ts

@@ -10,7 +10,7 @@ import { ASTNode, ObjectASTNode, PropertyASTNode } from '../jsonASTTypes';
 import { parse as parseYAML } from '../parser/yamlParser07';
 import { YAMLSchemaService } from './yamlSchemaService';
 import { JSONSchema, JSONSchemaRef } from '../jsonSchema';
-import { PromiseConstructor, Thenable, JSONWorkerContribution, CompletionsCollector } from 'vscode-json-languageservice';
+import { Thenable, CompletionsCollector } from 'vscode-json-languageservice';
 import {
   CompletionItem,
   CompletionItemKind,
@@ -26,7 +26,6 @@ import { getLineOffsets, filterInvalidCustomTags, matchOffsetToDocument } from '
 import { LanguageSettings } from '../yamlLanguageService';
 import { ResolvedSchema } from 'vscode-json-languageservice/lib/umd/services/jsonSchemaService';
 import { JSONCompletion } from 'vscode-json-languageservice/lib/umd/services/jsonCompletion';
-import { ClientCapabilities } from 'vscode-languageserver-protocol';
 import { stringifyObject, StringifySettings } from '../utils/json';
 import { guessIndentation } from '../utils/indentationGuesser';
 import { TextBuffer } from '../utils/textBuffer';
@@ -35,22 +34,14 @@ const localize = nls.loadMessageBundle();
 
 export class YAMLCompletion extends JSONCompletion {
   private schemaService: YAMLSchemaService;
-  private promise: PromiseConstructor;
   private customTags: Array<string>;
   private completion: boolean;
-  private supportsMarkdown: boolean | undefined;
   private indentation: string;
   private configuredIndentation: string | undefined;
 
-  constructor(
-    schemaService: YAMLSchemaService,
-    contributions: JSONWorkerContribution[] = [],
-    promiseConstructor: PromiseConstructor = Promise,
-    private clientCapabilities: ClientCapabilities = {}
-  ) {
-    super(schemaService, contributions, promiseConstructor);
+  constructor(schemaService: YAMLSchemaService) {
+    super(schemaService, [], Promise);
     this.schemaService = schemaService;
-    this.promise = promiseConstructor || Promise;
     this.customTags = [];
     this.completion = true;
   }
@@ -227,7 +218,7 @@ export class YAMLCompletion extends JSONCompletion {
         this.getValueCompletions(newSchema, currentDoc, node, offset, document, collector, types);
       }
 
-      return this.promise.all(collectionPromises).then(() => {
+      return Promise.all(collectionPromises).then(() => {
         return result;
       });
     });

src/languageservice/services/yamlHover.ts

@@ -5,7 +5,7 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import { PromiseConstructor, Thenable } from 'vscode-json-languageservice';
+import { Thenable } from 'vscode-json-languageservice';
 import { Hover, TextDocument, Position } from 'vscode-languageserver-types';
 import { matchOffsetToDocument } from '../utils/arrUtils';
 import { LanguageSettings } from '../yamlLanguageService';
@@ -15,12 +15,10 @@ import { JSONHover } from 'vscode-json-languageservice/lib/umd/services/jsonHove
 import { setKubernetesParserOption } from '../parser/isKubernetes';
 
 export class YAMLHover {
-  private promise: PromiseConstructor;
   private shouldHover: boolean;
   private jsonHover;
 
-  constructor(schemaService: YAMLSchemaService, promiseConstructor: PromiseConstructor) {
-    this.promise = promiseConstructor || Promise;
+  constructor(schemaService: YAMLSchemaService) {
     this.shouldHover = true;
     this.jsonHover = new JSONHover(schemaService, [], Promise);
   }
@@ -33,13 +31,13 @@ export class YAMLHover {
 
   public doHover(document: TextDocument, position: Position, isKubernetes = false): Thenable<Hover> {
     if (!this.shouldHover || !document) {
-      return this.promise.resolve(undefined);
+      return Promise.resolve(undefined);
     }
     const doc = parseYAML(document.getText());
     const offset = document.offsetAt(position);
     const currentDoc = matchOffsetToDocument(offset, doc);
     if (currentDoc === null) {
-      return this.promise.resolve(undefined);
+      return Promise.resolve(undefined);
     }
 
     setKubernetesParserOption(doc.documents, isKubernetes);

src/languageservice/services/yamlValidation.ts

@@ -6,7 +6,7 @@
 'use strict';
 
 import { Diagnostic } from 'vscode-languageserver-types';
-import { PromiseConstructor, LanguageSettings } from '../yamlLanguageService';
+import { LanguageSettings } from '../yamlLanguageService';
 import { parse as parseYAML, YAMLDocument } from '../parser/yamlParser07';
 import { SingleYAMLDocument } from '../parser/yamlParser07';
 import { YAMLSchemaService } from './yamlSchemaService';
@@ -30,17 +30,15 @@ export const yamlDiagToLSDiag = (yamlDiag: YAMLDocDiagnostic, textDocument: Text
 };
 
 export class YAMLValidation {
-  private promise: PromiseConstructor;
   private validationEnabled: boolean;
   private customTags: string[];
   private jsonValidation;
 
   private MATCHES_MULTIPLE = 'Matches multiple schemas when only one must validate.';
 
-  public constructor(schemaService: YAMLSchemaService, promiseConstructor: PromiseConstructor) {
-    this.promise = promiseConstructor || Promise;
+  public constructor(schemaService: YAMLSchemaService) {
     this.validationEnabled = true;
-    this.jsonValidation = new JSONValidation(schemaService, this.promise);
+    this.jsonValidation = new JSONValidation(schemaService, Promise);
   }
 
   public configure(settings: LanguageSettings): void {
@@ -52,7 +50,7 @@ export class YAMLValidation {
 
   public async doValidation(textDocument: TextDocument, isKubernetes = false): Promise<Diagnostic[]> {
     if (!this.validationEnabled) {
-      return this.promise.resolve([]);
+      return Promise.resolve([]);
     }
 
     const yamlDocument: YAMLDocument = parseYAML(textDocument.getText(), this.customTags);

src/languageservice/yamlLanguageService.ts

@@ -146,17 +146,13 @@ export interface LanguageService {
 
 export function getLanguageService(
   schemaRequestService: SchemaRequestService,
-  workspaceContext: WorkspaceContextService,
-  contributions: JSONWorkerContribution[],
-  promiseConstructor?: PromiseConstructor
+  workspaceContext: WorkspaceContextService
 ): LanguageService {
-  const promise = promiseConstructor || Promise;
-
   const schemaService = new YAMLSchemaService(schemaRequestService, workspaceContext);
-  const completer = new YAMLCompletion(schemaService, contributions, promise);
-  const hover = new YAMLHover(schemaService, promise);
+  const completer = new YAMLCompletion(schemaService);
+  const hover = new YAMLHover(schemaService);
   const yamlDocumentSymbols = new YAMLDocumentSymbols(schemaService);
-  const yamlValidation = new YAMLValidation(schemaService, promise);
+  const yamlValidation = new YAMLValidation(schemaService);
   const formatter = new YAMLFormatter();
 
   return {

src/server.ts

@@ -375,7 +375,7 @@ documents.listen(connection);
 
 const schemaRequestService = schemaRequestHandler.bind(this, connection);
 
-export const customLanguageService = getCustomLanguageService(schemaRequestService, workspaceContext, []);
+export const customLanguageService = getCustomLanguageService(schemaRequestService, workspaceContext);
 
 /***********************
  * Connection listeners

test/integration.test.ts

@@ -8,7 +8,7 @@ import * as assert from 'assert';
 import { MarkedString } from '../src';
 import { Diagnostic, CompletionList, Hover } from 'vscode-languageserver';
 
-const languageService = getLanguageService(schemaRequestService, workspaceContext, [], null);
+const languageService = getLanguageService(schemaRequestService, workspaceContext);
 
 const uri = 'https://raw.githubusercontent.com/instrumenta/kubernetes-json-schema/master/v1.17.0-standalone-strict/all.json';
 const languageSettings: LanguageSettings = {

test/utils/testHelper.ts

@@ -103,7 +103,7 @@ export function toFsPath(str: unknown): string {
 }
 
 export function configureLanguageService(languageSettings: LanguageSettings): LanguageService {
-  const languageService = getLanguageService(schemaRequestService, workspaceContext, [], null);
+  const languageService = getLanguageService(schemaRequestService, workspaceContext);
 
   languageService.configure(languageSettings);
   return languageService;