Cmi 90 relationship arrows aren t included in autocomplete

.github/workflows/build.yml

@@ -61,7 +61,7 @@ jobs:
         uses: JetBrains/qodana-action@v2024.3
         with:
           pr-mode: false
-          args: --linter,jetbrains/qodana-js:2024.3
+          args: --baseline,qodana.serif.json,--fail-threshold,2
         env:
           QODANA_TOKEN: ${{ secrets.QODANA_TOKEN_379728607 }}
           QODANA_ENDPOINT: 'https://qodana.cloud'

eslint.config.mjs

@@ -0,0 +1,31 @@
+import eslint from '@eslint/js'
+import typescriptEslint from 'typescript-eslint';
+
+export default typescriptEslint.config({
+        ignores: [
+            'esbuild.mjs',
+            'eslint.config.mjs',
+            '**/generated/**'
+        ],
+    },
+    eslint.configs.recommended,
+    typescriptEslint.configs.recommendedTypeChecked,
+    typescriptEslint.configs.stylisticTypeChecked,
+    {
+        languageOptions: {
+            parserOptions: {
+                project: ['./tsconfig.json']
+            }
+        },
+        rules: {
+            '@typescript-eslint/no-unused-vars': [
+                'error',
+                {
+                    'argsIgnorePattern': '^_',
+                    'varsIgnorePattern': '^_',
+                    'caughtErrorsIgnorePattern': '^_'
+                }
+            ]
+        }
+    }
+);

package.json

@@ -32,26 +32,23 @@
         "clean": "rm -rf src/language/generated && rm -rf cml-ls/ && rm -rf dist/"
     },
     "dependencies": {
-        "langium": "~3.4.0",
+        "langium": "~3.5.0",
         "vscode-languageserver": "~9.0.1",
         "vscode-languageserver-types": "~3.17.5"
     },
     "devDependencies": {
-        "@types/node": "^18.0.0",
-        "@typescript-eslint/eslint-plugin": "~7.3.1",
-        "@typescript-eslint/parser": "~7.3.1",
+        "@eslint/js": "^9.26.0",
+        "@types/node": "^22.15.17",
         "@vercel/ncc": "^0.38.3",
-        "@vitest/coverage-v8": "^3.1.1",
-        "concurrently": "~8.2.1",
-        "esbuild": "~0.20.2",
-        "eslint": "~8.57.0",
-        "eslint-config-standard": "^17.1.0",
-        "eslint-plugin-import": "^2.31.0",
-        "eslint-plugin-n": "^17.17.0",
-        "eslint-plugin-promise": "^7.2.1",
-        "langium-cli": "~3.4.0",
-        "typescript": "~5.1.6",
-        "vitest": "^3.1.1"
+        "@vitest/coverage-v8": "^3.1.3",
+        "concurrently": "~9.1.2",
+        "esbuild": "~0.25.4",
+        "eslint": "~9.26.0",
+        "jiti": "^2.4.2",
+        "langium-cli": "~3.5.0",
+        "typescript": "~5.8.3",
+        "typescript-eslint": "^8.32.0",
+        "vitest": "^3.1.3"
     },
     "packageManager": "yarn@4.8.1"
 }

src/language/ContextMapperDslModule.ts

@@ -21,15 +21,16 @@ import { KeywordHoverRegistry } from './hover/KeywordHoverRegistry.js'
 import { ContextMapperDslNodeKindProvider } from './shared/ContextMapperDslNodeKindProvider.js'
 import { ContextMapperDslFormatter } from './formatting/ContextMapperDslFormatter.js'
 import { ContextMapperFormatterRegistry } from './formatting/ContextMapperFormatterRegistry.js'
+import { ContextMapperDslCompletionProvider } from './completion/ContextMapperDslCompletionProvider.js'
 
 /**
  * Declaration of custom services - add your own service classes here.
  */
-export type ContextMapperDslAddedServices = {
+export interface ContextMapperDslAddedServices {
   validation: {
     ContextMapperDslValidator: ContextMapperDslValidator
   }
-};
+}
 
 /**
  * Union of Langium default services and your custom services - use this as constructor parameter
@@ -57,7 +58,8 @@ export const ContextMapperDslModule: Module<ContextMapperDslServices, ModuleType
     SemanticTokenProvider: (services) => new ContextMapperDslSemanticTokenProvider(services, semanticTokenProviderRegistry),
     FoldingRangeProvider: (services) => new ContextMapperDslFoldingRangeProvider(services),
     HoverProvider: (services) => new ContextMapperDslHoverProvider(services, new KeywordHoverRegistry()),
-    Formatter: () => new ContextMapperDslFormatter(new ContextMapperFormatterRegistry())
+    Formatter: () => new ContextMapperDslFormatter(new ContextMapperFormatterRegistry()),
+    CompletionProvider: (services) => new ContextMapperDslCompletionProvider(services)
   },
   references: {
     ScopeProvider: (services) => new ContextMapperDslScopeProvider(services),
@@ -102,7 +104,7 @@ export function createContextMapperDslServices (context: DefaultSharedModuleCont
   if (!context.connection) {
     // We don't run inside a language server
     // Therefore, initialize the configuration provider instantly
-    shared.workspace.ConfigurationProvider.initialized({})
+    void shared.workspace.ConfigurationProvider.initialized({})
   }
   return { shared, ContextMapperDsl }
 }

src/language/completion/ContextMapperDslCompletionProvider.ts

@@ -0,0 +1,13 @@
+import { CompletionContext, DefaultCompletionProvider } from 'langium/lsp'
+import { GrammarAST } from 'langium'
+
+export class ContextMapperDslCompletionProvider extends DefaultCompletionProvider {
+  /*
+  Langium hides non-alphabetical keywords by default. (see https://github.com/eclipse-langium/langium/pull/697)
+  This causes relationship arrows like '<->' to not be suggested in autocomplete.
+  Overriding this function allows all keywords to be suggested.
+   */
+  protected override filterKeyword (_context: CompletionContext, _keyword: GrammarAST.Keyword): boolean {
+    return true
+  }
+}

src/language/hover/ContextMapperDslHoverProvider.ts

@@ -6,6 +6,7 @@ import { KeywordHoverRegistry } from './KeywordHoverRegistry.js'
 
 export class ContextMapperDslHoverProvider extends MultilineCommentHoverProvider {
   private readonly _keywordHoverRegistry: KeywordHoverRegistry
+
   constructor (services: LangiumServices, keywordHoverRegistry: KeywordHoverRegistry) {
     super(services)
     this._keywordHoverRegistry = keywordHoverRegistry

src/language/hover/KeywordHoverRegistry.ts

@@ -1,5 +1,5 @@
 export class KeywordHoverRegistry {
-  private readonly _registry: Map<string, string> = new Map([
+  private readonly _registry = new Map<string, string>([
     [
       'BoundedContext',
       `**Bounded Context**: A description of a boundary (typically a subsystem, or the work of a particular team) within which a particular model is defined and applicable. \

src/language/main.ts

@@ -1,4 +1,4 @@
 import { startLanguageServer } from 'langium/lsp'
 import { NodeFileSystem } from 'langium/node'
 import { createConnection, ProposedFeatures } from 'vscode-languageserver/node.js'
 import { createContextMapperDslServices } from './ContextMapperDslModule.js'
@@ -7,7 +7,10 @@
 const connection = createConnection(ProposedFeatures.all)
 
 // Inject the shared services and language-specific services
-const { shared } = createContextMapperDslServices({ connection, ...NodeFileSystem })
+const { shared } = createContextMapperDslServices({
+  connection,
+  ...NodeFileSystem
+})
 
 // Start the language server with the shared services
 startLanguageServer(shared)

src/language/references/ContextMapperDslScopeComputation.ts

@@ -2,6 +2,7 @@ import { AstNode, AstNodeDescription, DefaultScopeComputation, LangiumDocument }
 import { CancellationToken } from 'vscode-languageserver'
 
 export class ContextMapperDslScopeComputation extends DefaultScopeComputation {
+
   /*
     For the time being imports aren't supported yet.
     By default, Langium adds top-level elements to the global scope.

src/language/references/ContextMapperDslScopeProvider.ts

@@ -4,10 +4,11 @@ import {
   Aggregate,
   DomainPart,
   isContextMappingModel,
-  isStakeholderGroup, StakeholderGroup
+  isStakeholderGroup
 } from '../generated/ast.js'
 
 export class ContextMapperDslScopeProvider extends DefaultScopeProvider {
+
   /*
     Some ContextMapper elements are not defined on the top-level of the document and should still be referencable.
     Langium assumes that nested elements don't belong in the global scope.
@@ -43,7 +44,7 @@ export class ContextMapperDslScopeProvider extends DefaultScopeProvider {
         .concat(
           model.stakeholders.flatMap(s => s.stakeholders)
             .filter(s => isStakeholderGroup(s))
-            .flatMap(sg => (sg as StakeholderGroup).stakeholders)
+            .flatMap(sg => sg.stakeholders)
             .map(s => this.descriptions.createDescription(s, s.name))
         )
       return this.createScope(stakeholderDescriptions)

src/language/semanticTokens/HighlightingHelper.ts

@@ -18,14 +18,6 @@ export function highlightKeyword (node: AstNode, acceptor: SemanticTokenAcceptor
   })
 }
 
-export function highlightOperator (node: AstNode, acceptor: SemanticTokenAcceptor, operator: string) {
-  acceptor({
-    node,
-    type: SemanticTokenTypes.operator,
-    keyword: operator
-  })
-}
-
 export function highlightType (node: AstNode, acceptor: SemanticTokenAcceptor, property: string, modifiers: string[] = []) {
   acceptor({
     node,
@@ -35,7 +27,7 @@ export function highlightType (node: AstNode, acceptor: SemanticTokenAcceptor, p
   })
 }
 
-export function highlightTypeDeclaration (node: AstNode, acceptor: SemanticTokenAcceptor, keyword: string, hasName: boolean = true) {
+export function highlightTypeDeclaration (node: AstNode, acceptor: SemanticTokenAcceptor, keyword: string, hasName = true) {
   highlightKeyword(node, acceptor, keyword)
   if (hasName) {
     highlightType(node, acceptor, 'name', [SemanticTokenModifiers.declaration])

src/language/semanticTokens/SemanticTokenProviderRegistry.ts

@@ -54,9 +54,13 @@ import {
 
 export class SemanticTokenProviderRegistry {
   private readonly _domainProvider = new DomainSemanticTokenProvider()
+
   private readonly _relationshipProvider = new RelationshipSemanticTokenProvider()
+
   private readonly _featureProvider = new FeatureSemanticTokenProvider()
+
   private readonly _userRequirementProvider = new RequirementsSemanticTokenProvider()
+
   private readonly _stakeholderProvider = new AbstractStakeholderSemanticTokenProvider()
 
   private readonly semanticTokenProviders = new Map<string, ContextMapperSemanticTokenProvider<AstNode>>([

src/language/semanticTokens/contextMap/RelationshipSemanticTokenProvider.ts

@@ -14,7 +14,7 @@ import {
 import { SemanticTokenAcceptor } from 'langium/lsp'
 import { SemanticTokenModifiers, SemanticTokenTypes } from 'vscode-languageserver-types'
 import { ContextMapperSemanticTokenProvider } from '../ContextMapperSemanticTokenProvider.js'
-import { highlightField, highlightKeyword, highlightOperator, highlightType } from '../HighlightingHelper.js'
+import { highlightField, highlightKeyword, highlightType } from '../HighlightingHelper.js'
 
 export class RelationshipSemanticTokenProvider implements ContextMapperSemanticTokenProvider<Relationship> {
   highlight (node: Relationship, acceptor: SemanticTokenAcceptor) {
@@ -46,13 +46,13 @@ export class RelationshipSemanticTokenProvider implements ContextMapperSemanticT
 
   private highlightPartnership (node: Partnership, acceptor: SemanticTokenAcceptor) {
     highlightKeyword(node, acceptor, 'P')
-    highlightOperator(node, acceptor, '<->')
+    highlightKeyword(node, acceptor, '<->')
     highlightKeyword(node, acceptor, 'Partnership')
   }
 
   private highlightSharedKernel (node: SharedKernel, acceptor: SemanticTokenAcceptor) {
     highlightKeyword(node, acceptor, 'SK')
-    highlightOperator(node, acceptor, '<->')
+    highlightKeyword(node, acceptor, '<->')
     highlightKeyword(node, acceptor, 'Shared-Kernel')
   }
 
@@ -77,8 +77,8 @@ export class RelationshipSemanticTokenProvider implements ContextMapperSemanticT
       })
     }
 
-    highlightOperator(node, acceptor, '->')
-    highlightOperator(node, acceptor, '<-')
+    highlightKeyword(node, acceptor, '->')
+    highlightKeyword(node, acceptor, '<-')
 
     if (node.upstreamExposedAggregates.length > 0) {
       highlightField(node, acceptor, ['exposedAggregates'], 'upstreamExposedAggregates', SemanticTokenTypes.type)

src/language/validation/ContextMapperDslValidationRegistry.ts

@@ -1,4 +1,4 @@
-import { type ValidationChecks, ValidationRegistry } from 'langium'
+import { AstNode, ValidationAcceptor, type ValidationChecks, ValidationRegistry } from 'langium'
 import { ContextMapperDslServices } from '../ContextMapperDslModule.js'
 import { ContextMapperDslAstType } from '../generated/ast.js'
 import { ContextMapperValidationProviderRegistry } from './ContextMapperValidationProviderRegistry.js'
@@ -12,7 +12,7 @@ export class ContextMapperDslValidationRegistry extends ValidationRegistry {
 
     // dynamically set validator for all grammar elements
     const checks: ValidationChecks<ContextMapperDslAstType> = Object.fromEntries(
-      typesToValidate.map(type => [type, validator.validate])
+      typesToValidate.map(type => [type, (node: AstNode, acceptor: ValidationAcceptor) => validator.validate(node, acceptor)])
     )
 
     super.register(checks, validator)

src/language/validation/ContextMapperValidationProvider.ts

@@ -1,5 +1,5 @@
 import { AstNode, ValidationAcceptor } from 'langium'
 
 export interface ContextMapperValidationProvider<T extends AstNode> {
-  validate (node: T, acceptor: ValidationAcceptor): void
+  validate (_node: T, _acceptor: ValidationAcceptor): void
 }

src/language/validation/impl/AggregateValidationProvider.ts

@@ -21,9 +21,9 @@ export class AggregateValidationProvider implements ContextMapperValidationProvi
     enforceZeroOrOneCardinality(node, 'securityAccessGroup', acceptor)
 
     // make sure only one of the userRequirements keywords is used
-    const userRequirementProperties = ['userRequirements', 'useCases', 'userStories'] as Array<keyof Aggregate>
+    const userRequirementProperties = ['userRequirements', 'useCases', 'userStories'] as (keyof Aggregate)[]
     const setUserRequirements = userRequirementProperties.filter(p => {
-      const value = node[p] as Array<any>
+      const value = node[p] as object[]
       return value.length > 0
     })
     if (setUserRequirements.length > 1) {

src/language/validation/impl/SubDomainValidationProvider.ts

@@ -1,9 +1,10 @@
 import { ContextMapperValidationProvider } from '../ContextMapperValidationProvider.js'
 import { Subdomain } from '../../generated/ast.js'
 import { enforceZeroOrOneCardinality } from '../ValidationHelper.js'
+import { ValidationAcceptor } from 'langium'
 
 export class SubDomainValidationProvider implements ContextMapperValidationProvider<Subdomain> {
-  validate (node: Subdomain, acceptor: any): void {
+  validate (node: Subdomain, acceptor: ValidationAcceptor): void {
     enforceZeroOrOneCardinality(node, 'type', acceptor)
     enforceZeroOrOneCardinality(node, 'domainVisionStatement', acceptor)
   }

test/ParsingTestHelper.ts

@@ -8,7 +8,7 @@ export async function parseValidInput (parse: ReturnType<typeof parseHelper<Cont
 
   expectNoParsingErrors(document)
   expect(document.parseResult.lexerErrors).toHaveLength(0)
-  expect(document.diagnostics || []).toHaveLength(0)
+  expect(document.diagnostics ?? []).toHaveLength(0)
 
   return document
 }

test/completion/Completion.test.ts

@@ -6,12 +6,13 @@ import { EmptyFileSystem, LangiumDocument } from 'langium'
 import { afterEach, beforeAll, describe, expect, test } from 'vitest'
 import { fail } from 'node:assert'
 import { uinteger } from 'vscode-languageserver-types'
+import { CompletionParams } from 'vscode-languageserver'
 
 let services: ReturnType<typeof createContextMapperDslServices>
 let completionProvider: CompletionProvider
 let parse: ReturnType<typeof parseHelper<ContextMappingModel>>
 
-beforeAll(async () => {
+beforeAll(() => {
   services = createContextMapperDslServices(EmptyFileSystem)
   completionProvider = services.ContextMapperDsl.lsp.CompletionProvider!
   parse = parseHelper<ContextMappingModel>(services.ContextMapperDsl)
@@ -84,9 +85,29 @@ describe('Completion tests', () => {
     expect(completionList.items).toHaveLength(1)
     expect(completionList.items[0].label).toEqual('type')
   })
+
+  test('check completion of relationship arrows', async () => {
+    const docToComplete = await parse(`
+      ContextMap {
+        AnotherContext 
+      }
+      BoundedContext TestContext
+      BoundedContext AnotherContext
+    `)
+
+    const params = createCompletionParams(docToComplete, 2, 23)
+    const completionList = await completionProvider.getCompletion(docToComplete, params)
+    if (completionList == null) {
+      fail('Expected completion provider to return completion list')
+      return
+    }
+
+    const suggestions = completionList.items.map(item => item.label)
+    expect(suggestions).toContain('<->')
+  })
 })
 
-function createCompletionParams (document: LangiumDocument<ContextMappingModel>, positionLine: uinteger, positionChar: uinteger): any {
+function createCompletionParams (document: LangiumDocument<ContextMappingModel>, positionLine: uinteger, positionChar: uinteger): CompletionParams {
   return {
     textDocument: {
       uri: document.uri.path

test/documentSymbol/DocumentSymbolProvider.test.ts

@@ -11,14 +11,14 @@ let parse: ReturnType<typeof parseHelper<ContextMappingModel>>
 let document: LangiumDocument<ContextMappingModel> | undefined
 let documentSymbolProvider: DocumentSymbolProvider
 
-beforeAll(async () => {
+beforeAll(() => {
   services = createContextMapperDslServices(EmptyFileSystem)
   parse = parseHelper<ContextMappingModel>(services.ContextMapperDsl)
   documentSymbolProvider = services.ContextMapperDsl.lsp.DocumentSymbolProvider!
 })
 
 afterEach(async () => {
-  document && await clearDocuments(services.shared, [document])
+  if (document) await clearDocuments(services.shared, [document])
 })
 
 describe('Document symbol provider tests', () => {