1 files changed, 177 insertions, 0 deletions

diff --git a/language-web/src/main/js/xtext/ContentAssistService.ts b/language-web/src/main/js/xtext/ContentAssistService.ts
new file mode 100644
index 00000000..f085c5b1
--- /dev/null
+++ b/language-web/src/main/js/xtext/ContentAssistService.ts
@@ -0,0 +1,177 @@
+import type {
+  Completion,
+  CompletionContext,
+  CompletionResult,
+} from '@codemirror/autocomplete';
+import type { Transaction } from '@codemirror/state';
+import escapeStringRegexp from 'escape-string-regexp';
+
+import type { UpdateService } from './UpdateService';
+import { getLogger } from '../utils/logger';
+import type { IContentAssistEntry } from './xtextServiceResults';
+
+const PROPOSALS_LIMIT = 1000;
+
+const IDENTIFIER_REGEXP_STR = '[a-zA-Z0-9_]*';
+
+const HIGH_PRIORITY_KEYWORDS = ['<->'];
+
+const QUALIFIED_NAME_SEPARATOR_REGEXP = /::/g;
+
+const log = getLogger('xtext.ContentAssistService');
+
+function createCompletion(entry: IContentAssistEntry): Completion {
+  let boost;
+  switch (entry.kind) {
+    case 'KEYWORD':
+      // Some hard-to-type operators should be on top.
+      boost = HIGH_PRIORITY_KEYWORDS.includes(entry.proposal) ? 10 : -99;
+      break;
+    case 'TEXT':
+    case 'SNIPPET':
+      boost = -90;
+      break;
+    default: {
+      // Penalize qualified names (vs available unqualified names).
+      const extraSegments = entry.proposal.match(QUALIFIED_NAME_SEPARATOR_REGEXP)?.length || 0;
+      boost = Math.max(-5 * extraSegments, -50);
+    }
+      break;
+  }
+  return {
+    label: entry.proposal,
+    detail: entry.description,
+    info: entry.documentation,
+    type: entry.kind?.toLowerCase(),
+    boost,
+  };
+}
+
+function computeSpan(prefix: string, entryCount: number) {
+  const escapedPrefix = escapeStringRegexp(prefix);
+  if (entryCount < PROPOSALS_LIMIT) {
+    // Proposals with the current prefix fit the proposals limit.
+    // We can filter client side as long as the current prefix is preserved.
+    return new RegExp(`^${escapedPrefix}${IDENTIFIER_REGEXP_STR}$`);
+  }
+  // The current prefix overflows the proposals limits,
+  // so we have to fetch the completions again on the next keypress.
+  // Hopefully, it'll return a shorter list and we'll be able to filter client side.
+  return new RegExp(`^${escapedPrefix}$`);
+}
+
+export class ContentAssistService {
+  private readonly updateService: UpdateService;
+
+  private lastCompletion: CompletionResult | null = null;
+
+  constructor(updateService: UpdateService) {
+    this.updateService = updateService;
+  }
+
+  onTransaction(transaction: Transaction): void {
+    if (this.shouldInvalidateCachedCompletion(transaction)) {
+      this.lastCompletion = null;
+    }
+  }
+
+  async contentAssist(context: CompletionContext): Promise<CompletionResult> {
+    const tokenBefore = context.tokenBefore(['QualifiedName']);
+    let range: { from: number, to: number };
+    let prefix = '';
+    if (tokenBefore === null) {
+      if (!context.explicit) {
+        return {
+          from: context.pos,
+          options: [],
+        };
+      }
+      range = {
+        from: context.pos,
+        to: context.pos,
+      };
+      prefix = '';
+    } else {
+      range = {
+        from: tokenBefore.from,
+        to: tokenBefore.to,
+      };
+      const prefixLength = context.pos - tokenBefore.from;
+      if (prefixLength > 0) {
+        prefix = tokenBefore.text.substring(0, context.pos - tokenBefore.from);
+      }
+    }
+    if (!context.explicit && this.shouldReturnCachedCompletion(tokenBefore)) {
+      log.trace('Returning cached completion result');
+      // Postcondition of `shouldReturnCachedCompletion`: `lastCompletion !== null`
+      return {
+        ...this.lastCompletion as CompletionResult,
+        ...range,
+      };
+    }
+    this.lastCompletion = null;
+    const entries = await this.updateService.fetchContentAssist({
+      resource: this.updateService.resourceName,
+      serviceType: 'assist',
+      caretOffset: context.pos,
+      proposalsLimit: PROPOSALS_LIMIT,
+    }, context);
+    if (context.aborted) {
+      return {
+        ...range,
+        options: [],
+      };
+    }
+    const options: Completion[] = [];
+    entries.forEach((entry) => {
+      options.push(createCompletion(entry));
+    });
+    log.debug('Fetched', options.length, 'completions from server');
+    this.lastCompletion = {
+      ...range,
+      options,
+      span: computeSpan(prefix, entries.length),
+    };
+    return this.lastCompletion;
+  }
+
+  private shouldReturnCachedCompletion(
+    token: { from: number, to: number, text: string } | null,
+  ) {
+    if (token === null || this.lastCompletion === null) {
+      return false;
+    }
+    const { from, to, text } = token;
+    const { from: lastFrom, to: lastTo, span } = this.lastCompletion;
+    if (!lastTo) {
+      return true;
+    }
+    const [transformedFrom, transformedTo] = this.mapRangeInclusive(lastFrom, lastTo);
+    return from >= transformedFrom && to <= transformedTo && span && span.exec(text);
+  }
+
+  private shouldInvalidateCachedCompletion(transaction: Transaction) {
+    if (!transaction.docChanged || this.lastCompletion === null) {
+      return false;
+    }
+    const { from: lastFrom, to: lastTo } = this.lastCompletion;
+    if (!lastTo) {
+      return true;
+    }
+    const [transformedFrom, transformedTo] = this.mapRangeInclusive(lastFrom, lastTo);
+    let invalidate = false;
+    transaction.changes.iterChangedRanges((fromA, toA) => {
+      if (fromA < transformedFrom || toA > transformedTo) {
+        invalidate = true;
+      }
+    });
+    return invalidate;
+  }
+
+  private mapRangeInclusive(lastFrom: number, lastTo: number): [number, number] {
+    const changes = this.updateService.computeChangesSinceLastUpdate();
+    const transformedFrom = changes.mapPos(lastFrom);
+    const transformedTo = changes.mapPos(lastTo, 1);
+    return [transformedFrom, transformedTo];
+  }
+}