@likec4/language-server 1.18.0 → 1.19.1

package/src/validation/index.ts

@@ -1,4 +1,7 @@
-import { type ast } from '../ast'
+import type { AstNode } from 'langium'
+import { isNullish } from 'remeda'
+import { DiagnosticSeverity } from 'vscode-languageserver-types'
+import { type LikeC4AstNode, type LikeC4LangiumDocument, ast } from '../ast'
 import { logger } from '../logger'
 import type { LikeC4Services } from '../module'
 import { deployedInstanceChecks, deploymentNodeChecks, deploymentRelationChecks } from './deployment-checks'
@@ -15,27 +18,115 @@ import {
   modelRuleChecks,
   relationshipChecks,
   specificationRuleChecks,
-  tagChecks
+  tagChecks,
 } from './specification'
 import { viewChecks } from './view'
 import {
-  deploymentRefExpressionChecks,
   elementPredicateWithChecks,
   expandElementExprChecks,
+  fqnRefExprChecks,
   incomingExpressionChecks,
   outgoingExpressionChecks,
-  relationPredicateWithChecks
+  relationExprChecks,
+  relationPredicateWithChecks,
 } from './view-predicates'
 
+type Guard<N extends AstNode> = (n: AstNode) => n is N
+type Guarded<G> = G extends Guard<infer N> ? N : never
+
+function validatableAstNodeGuards<const Predicates extends Guard<AstNode>[]>(
+  predicates: Predicates,
+) {
+  return (n: AstNode): n is Guarded<Predicates[number]> => predicates.some(p => p(n))
+}
+const isValidatableAstNode = validatableAstNodeGuards([
+  ast.isGlobals,
+  ast.isGlobalPredicateGroup,
+  ast.isGlobalDynamicPredicateGroup,
+  ast.isGlobalStyle,
+  ast.isGlobalStyleGroup,
+  ast.isDynamicViewPredicateIterator,
+  ast.isElementPredicateWith,
+  ast.isRelationPredicateWith,
+  ast.isElementExpression,
+  ast.isRelationExpression,
+  ast.isDynamicViewParallelSteps,
+  ast.isDynamicViewStep,
+  ast.isDeploymentViewRule,
+  ast.isDeploymentViewRulePredicate,
+  ast.isExpressionV2,
+  ast.isRelationExpr,
+  ast.isFqnRefExpr,
+  ast.isViewProperty,
+  ast.isStyleProperty,
+  ast.isPredicate,
+  ast.isTags,
+  ast.isViewRule,
+  ast.isDynamicViewRule,
+  ast.isLikeC4View,
+  ast.isViewRuleStyleOrGlobalRef,
+  ast.isDeployedInstance,
+  ast.isDeploymentNode,
+  ast.isDeploymentRelation,
+  ast.isRelationshipStyleProperty,
+  ast.isMetadataProperty,
+  ast.isRelation,
+  ast.isElementProperty,
+  ast.isStringProperty,
+  ast.isNavigateToProperty,
+  ast.isElement,
+  ast.isExtendElement,
+  ast.isSpecificationElementKind,
+  ast.isSpecificationRelationshipKind,
+  ast.isSpecificationDeploymentNodeKind,
+  ast.isSpecificationTag,
+  ast.isSpecificationColor,
+  ast.isSpecificationRule,
+])
+type ValidatableAstNode = Guarded<typeof isValidatableAstNode>
+
+const findInvalidContainer = (node: LikeC4AstNode): ValidatableAstNode | undefined => {
+  let nd = node as LikeC4AstNode['$container']
+  while (nd && !ast.isLikeC4Grammar(nd)) {
+    if (isValidatableAstNode(nd)) {
+      return nd
+    }
+    nd = nd.$container
+  }
+  return undefined
+}
+
+export function checksFromDiagnostics(doc: LikeC4LangiumDocument) {
+  const errors = doc.diagnostics?.filter(d => d.severity === DiagnosticSeverity.Error) ?? []
+  const invalidNodes = new WeakSet()
+  for (const { node } of errors) {
+    if (isNullish(node) || invalidNodes.has(node)) {
+      continue
+    }
+    invalidNodes.add(node)
+    const container = findInvalidContainer(node)
+    if (container) {
+      invalidNodes.add(container)
+    }
+  }
+  const isValid = (n: ValidatableAstNode) => !invalidNodes.has(n)
+  return {
+    isValid,
+    invalidNodes,
+  }
+}
+export type ChecksFromDiagnostics = ReturnType<typeof checksFromDiagnostics>
+export type IsValidFn = ChecksFromDiagnostics['isValid']
+
 export function registerValidationChecks(services: LikeC4Services) {
-  logger.info('registerValidationChecks')
+  logger.debug('registerValidationChecks')
   const registry = services.validation.ValidationRegistry
   registry.register<ast.LikeC4AstType>({
     DeployedInstance: deployedInstanceChecks(services),
     DeploymentNode: deploymentNodeChecks(services),
     DeploymentRelation: deploymentRelationChecks(services),
-    DeploymentRefExpression: deploymentRefExpressionChecks(services),
-    // DeploymentRelationExpression: deploymentRelationExpressionChecks(services),
+    FqnRefExpr: fqnRefExprChecks(services),
+    RelationExpr: relationExprChecks(services),
     NotesProperty: notesPropertyRuleChecks(services),
     OpacityProperty: opacityPropertyRuleChecks(services),
     IconProperty: iconPropertyRuleChecks(services),
@@ -58,7 +149,7 @@ export function registerValidationChecks(services: LikeC4Services) {
     ExpandElementExpression: expandElementExprChecks(services),
     RelationshipKind: relationshipChecks(services),
     IncomingRelationExpression: incomingExpressionChecks(services),
-    OutgoingRelationExpression: outgoingExpressionChecks(services)
+    OutgoingRelationExpression: outgoingExpressionChecks(services),
   })
   const connection = services.shared.lsp.Connection
   if (connection) {
@@ -68,7 +159,7 @@ export function registerValidationChecks(services: LikeC4Services) {
         logger.debug(`clear diagnostics for deleted ${uri.path}`)
         void connection.sendDiagnostics({
           uri: uri.toString(),
-          diagnostics: []
+          diagnostics: [],
         })
       }
     })

package/src/validation/property-checks.ts

@@ -1,30 +1,31 @@
-import { AstUtils, type ValidationCheck } from 'langium'
+import { type ValidationCheck, AstUtils } from 'langium'
 import { ast } from '../ast'
 import type { LikeC4Services } from '../module'
+import { tryOrLog } from './_shared'
 
 export const opacityPropertyRuleChecks = (
-  _: LikeC4Services
+  _: LikeC4Services,
 ): ValidationCheck<ast.OpacityProperty> => {
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     const opacity = parseFloat(node.value)
     if (isNaN(opacity) || opacity < 0 || opacity > 100) {
       accept('warning', `Value ignored, must be between 0% and 100%`, {
         node,
-        property: 'value'
+        property: 'value',
       })
     }
-  }
+  })
 }
 
 export const iconPropertyRuleChecks = (
-  _: LikeC4Services
+  _: LikeC4Services,
 ): ValidationCheck<ast.IconProperty> => {
   return (node, accept) => {
     const container = node.$container
     const anotherIcon = container.props.some(p => ast.isIconProperty(p) && p !== node)
     if (anotherIcon) {
       accept('error', `Icon must be defined once`, {
-        node
+        node,
       })
     }
     if (
@@ -32,19 +33,19 @@ export const iconPropertyRuleChecks = (
       && container.$container.props.some(p => ast.isIconProperty(p))
     ) {
       accept('warning', `Redundant as icon defined on element`, {
-        node
+        node,
       })
     }
   }
 }
 
 export const notesPropertyRuleChecks = (
-  _: LikeC4Services
+  _: LikeC4Services,
 ): ValidationCheck<ast.NotesProperty> => {
   return (node, accept) => {
     if (!AstUtils.hasContainerOfType(node, ast.isDynamicViewStep)) {
       accept('error', `Notes can be defined only inside dynamic view`, {
-        node
+        node,
       })
     }
   }

package/src/validation/specification.ts

@@ -1,41 +1,41 @@
-import { AstUtils, type ValidationCheck } from 'langium'
+import { type ValidationCheck, AstUtils } from 'langium'
 import { ast } from '../ast'
 import type { LikeC4Services } from '../module'
 import { RESERVED_WORDS, tryOrLog } from './_shared'
 
 export const specificationRuleChecks = (
-  _: LikeC4Services
+  _: LikeC4Services,
 ): ValidationCheck<ast.SpecificationRule> => {
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     if (node.$containerIndex && node.$containerIndex > 0) {
       accept('warning', `Prefer one specification per document`, {
         node: node,
-        property: 'name'
+        property: 'name',
       })
     }
-  }
+  })
 }
 
 export const modelRuleChecks = (_: LikeC4Services): ValidationCheck<ast.Model> => {
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     if (node.$containerIndex && node.$containerIndex > 0) {
       accept('warning', `Prefer one model per document`, {
         node: node,
-        property: 'name'
+        property: 'name',
       })
     }
-  }
+  })
 }
 
 export const globalsChecks = (_: LikeC4Services): ValidationCheck<ast.Globals> => {
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     if (node.$containerIndex && node.$containerIndex > 0) {
       accept('warning', `Prefer one global block per document`, {
         node: node,
-        property: 'name'
+        property: 'name',
       })
     }
-  }
+  })
 }
 
 export const elementKindChecks = (services: LikeC4Services): ValidationCheck<ast.ElementKind> => {
@@ -44,7 +44,7 @@ export const elementKindChecks = (services: LikeC4Services): ValidationCheck<ast
     if (RESERVED_WORDS.includes(node.name)) {
       accept('error', `Reserved word: ${node.name}`, {
         node: node,
-        property: 'name'
+        property: 'name',
       })
     }
     const sameKind = index
@@ -61,12 +61,12 @@ export const elementKindChecks = (services: LikeC4Services): ValidationCheck<ast
             {
               location: {
                 range: sameKind.nameSegment!.range,
-                uri: sameKind.documentUri.toString()
+                uri: sameKind.documentUri.toString(),
               },
-              message: `conflicting definition`
-            }
-          ]
-        }
+              message: `conflicting definition`,
+            },
+          ],
+        },
       })
     }
   })
@@ -74,7 +74,7 @@ export const elementKindChecks = (services: LikeC4Services): ValidationCheck<ast
 
 export const tagChecks = (services: LikeC4Services): ValidationCheck<ast.Tag> => {
   const index = services.shared.workspace.IndexManager
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     const tagname = '#' + node.name
     const sameTag = index
       .allElements(ast.Tag)
@@ -93,27 +93,27 @@ export const tagChecks = (services: LikeC4Services): ValidationCheck<ast.Tag> =>
               {
                 location: {
                   range: sameTag.nameSegment!.range,
-                  uri: sameTag.documentUri.toString()
+                  uri: sameTag.documentUri.toString(),
                 },
-                message: `conflicting definition`
-              }
-            ]
-          }
-        }
+                message: `conflicting definition`,
+              },
+            ],
+          },
+        },
       )
     }
-  }
+  })
 }
 
 export const relationshipChecks = (
-  services: LikeC4Services
+  services: LikeC4Services,
 ): ValidationCheck<ast.RelationshipKind> => {
   const index = services.shared.workspace.IndexManager
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     if (RESERVED_WORDS.includes(node.name)) {
       accept('error', `Reserved word: ${node.name}`, {
         node: node,
-        property: 'name'
+        property: 'name',
       })
     }
     const sameKinds = index
@@ -124,17 +124,17 @@ export const relationshipChecks = (
     if (sameKinds > 1) {
       accept('error', `Duplicate RelationshipKind '${node.name}'`, {
         node: node,
-        property: 'name'
+        property: 'name',
       })
     }
-  }
+  })
 }
 
 export const globalPredicateChecks = (
-  services: LikeC4Services
+  services: LikeC4Services,
 ): ValidationCheck<ast.GlobalPredicateGroup | ast.GlobalDynamicPredicateGroup> => {
   const index = services.shared.workspace.IndexManager
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     const predicateGroups = index.allElements(ast.GlobalPredicateGroup)
     const dynamicPredicateGroups = index.allElements(ast.GlobalDynamicPredicateGroup)
     const sameName = predicateGroups
@@ -145,17 +145,17 @@ export const globalPredicateChecks = (
     if (sameName > 1) {
       accept('error', `Duplicate GlobalPredicateGroup or GlobalDynamicPredicateGroup name '${node.name}'`, {
         node: node,
-        property: 'name'
+        property: 'name',
       })
     }
-  }
+  })
 }
 
 export const globalStyleIdChecks = (
-  services: LikeC4Services
+  services: LikeC4Services,
 ): ValidationCheck<ast.GlobalStyleId> => {
   const index = services.shared.workspace.IndexManager
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
     const sameName = index
       .allElements(ast.GlobalStyleId)
       .filter(s => s.name === node.name)
@@ -164,8 +164,8 @@ export const globalStyleIdChecks = (
     if (sameName > 1) {
       accept('error', `Duplicate GlobalStyleId name '${node.name}'`, {
         node: node,
-        property: 'name'
+        property: 'name',
       })
     }
-  }
+  })
 }

package/src/validation/view-predicates/element-with.ts

@@ -3,15 +3,16 @@ import type { ValidationCheck } from 'langium'
 import { AstUtils } from 'langium'
 import { ast } from '../../ast'
 import type { LikeC4Services } from '../../module'
+import { tryOrLog } from '../_shared'
 
 export const elementPredicateWithChecks = (
-  _services: LikeC4Services
+  _services: LikeC4Services,
 ): ValidationCheck<ast.ElementPredicateWith> => {
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     const container = AstUtils.getContainerOfType(el, ast.isViewRulePredicate)
     if (ast.isExcludePredicate(container)) {
       accept('error', 'Invalid usage inside "exclude"', {
-        node: el
+        node: el,
       })
     }
     const subject = ast.isElementPredicateWhere(el.subject) ? el.subject.subject : el.subject
@@ -25,11 +26,11 @@ export const elementPredicateWithChecks = (
       case ast.isElementTagExpression(subject):
         accept('error', 'Invalid target (expect reference to specific element)', {
           node: el,
-          property: 'subject'
+          property: 'subject',
         })
         return
       default:
         nonexhaustive(subject)
     }
-  }
+  })
 }

package/src/validation/view-predicates/expanded-element.ts

@@ -1,15 +1,16 @@
-import { AstUtils, type ValidationCheck } from 'langium'
+import { type ValidationCheck, AstUtils } from 'langium'
 import { ast } from '../../ast'
 import type { LikeC4Services } from '../../module'
+import { tryOrLog } from '../_shared'
 
 export const expandElementExprChecks = (
-  _services: LikeC4Services
+  _services: LikeC4Services,
 ): ValidationCheck<ast.ExpandElementExpression> => {
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     if (AstUtils.hasContainerOfType(el, ast.isRelationExpression)) {
       accept('warning', `Redundant usage, expand predicate resolves parent element only when used in relations`, {
-        node: el
+        node: el,
       })
     }
-  }
+  })
 }

package/src/validation/view-predicates/expression-v2.ts

@@ -0,0 +1,101 @@
+import { FqnExpr, FqnRef } from '@likec4/core'
+import { AstUtils, type ValidationCheck } from 'langium'
+import { isNonNullish, isNullish } from 'remeda'
+import { ast } from '../../ast'
+import type { LikeC4Services } from '../../module'
+import { tryOrLog } from '../_shared'
+
+export const relationExprChecks = (services: LikeC4Services): ValidationCheck<ast.RelationExpr> => {
+  const ModelParser = services.likec4.ModelParser
+  return tryOrLog((node, accept) => {
+    if (node.$container.$type !== 'DeploymentViewRulePredicateExpression') {
+      // skip validation for this node, validated by container
+      return
+    }
+
+    const predicate = AstUtils.getContainerOfType(node, ast.isDeploymentViewRulePredicate)
+    if (!predicate || predicate.isInclude !== true) {
+      // no restriction for exclude predicate
+      return
+    }
+
+    const doc = AstUtils.getDocument(node)
+    const parser = ModelParser.forDocument(doc)
+
+    const ModelRefOnlyExclude = 'Model reference is allowed in exclude predicate only'
+
+    if (ast.isDirectedRelationExpr(node)) {
+      if (FqnExpr.isModelRef(parser.parseFqnExpr(node.source.from))) {
+        accept('error', ModelRefOnlyExclude, {
+          node: node.source,
+          property: 'from'
+        })
+      }
+
+      if (FqnExpr.isModelRef(parser.parseFqnExpr(node.target))) {
+        accept('error', ModelRefOnlyExclude, {
+          node,
+          property: 'target'
+        })
+      }
+      return
+    }
+
+    let expr: ast.FqnExpr
+    if (ast.isIncomingRelationExpr(node)) {
+      expr = node.to
+    } else if (ast.isOutgoingRelationExpr(node)) {
+      expr = node.from
+    } else {
+      expr = node.inout.to
+    }
+    if (FqnExpr.isModelRef(parser.parseFqnExpr(expr))) {
+      accept('error', ModelRefOnlyExclude, {
+        node
+      })
+      return
+    }
+  })
+}
+
+export const fqnRefExprChecks = (services: LikeC4Services): ValidationCheck<ast.FqnRefExpr> => {
+  const ModelParser = services.likec4.ModelParser
+  // const DeploymentsIndex = services.likec4.DeploymentsIndex
+  // const Names = services.references.NameProvider as LikeC4NameProvider
+  // const Locator = services.workspace.AstNodeLocator
+  // const fqnIndex = services.likec4.FqnIndex
+  return tryOrLog((node, accept) => {
+    const referenceTo = node.ref.value.ref
+    if (isNullish(referenceTo)) {
+      accept('error', 'Invalid empty reference', {
+        node
+      })
+      return
+    }
+    const doc = AstUtils.getDocument(node)
+    const expr = ModelParser.forDocument(doc).parseFqnRefExpr(node)
+
+    // This expression is part of element predicate
+    if (node.$container.$type === 'DeploymentViewRulePredicateExpression') {
+      if (FqnExpr.isModelRef(expr)) {
+        accept('error', 'Deployment view predicate must reference deployment model', {
+          node
+        })
+        return
+      }
+      if (FqnExpr.isDeploymentRef(expr) && FqnRef.isInsideInstanceRef(expr.ref)) {
+        accept('error', 'Must reference deployment nodes or instances, but not internals', {
+          node
+        })
+        return
+      }
+    }
+
+    if (!ast.isDeploymentNode(referenceTo) && isNonNullish(node.selector)) {
+      accept('warning', `Selector '${node.selector}' applies to deployment nodes only, ignored here`, {
+        node,
+        property: 'selector'
+      })
+    }
+  })
+}

package/src/validation/view-predicates/incoming.ts

@@ -1,19 +1,20 @@
-import { AstUtils, type ValidationCheck } from 'langium'
+import { type ValidationCheck, AstUtils } from 'langium'
 import { isNullish } from 'remeda'
 import { ast } from '../../ast'
 import type { LikeC4Services } from '../../module'
+import { tryOrLog } from '../_shared'
 
 export const incomingExpressionChecks = (
-  _services: LikeC4Services
+  _services: LikeC4Services,
 ): ValidationCheck<ast.IncomingRelationExpression> => {
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     if (ast.isWildcardExpression(el.to) && !ast.isInOutRelationExpression(el.$container)) {
       const view = AstUtils.getContainerOfType(el, ast.isElementView)
       if (isNullish(view?.viewOf)) {
         accept('warning', 'Predicate is ignored as it concerns all relationships', {
-          node: el
+          node: el,
         })
       }
     }
-  }
+  })
 }

package/src/validation/view-predicates/index.ts

@@ -1,6 +1,6 @@
-export * from './deployments'
 export * from './element-with'
 export * from './expanded-element'
+export * from './expression-v2'
 export * from './incoming'
 export * from './outgoing'
 export * from './relation-with'

package/src/validation/view-predicates/outgoing.ts

@@ -1,19 +1,20 @@
-import { AstUtils, type ValidationCheck } from 'langium'
+import { type ValidationCheck, AstUtils } from 'langium'
 import { isNullish } from 'remeda'
 import { ast } from '../../ast'
 import type { LikeC4Services } from '../../module'
+import { tryOrLog } from '../_shared'
 
 export const outgoingExpressionChecks = (
-  _services: LikeC4Services
+  _services: LikeC4Services,
 ): ValidationCheck<ast.OutgoingRelationExpression> => {
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     if (ast.isWildcardExpression(el.from) && !ast.isDirectedRelationExpression(el.$container)) {
       const view = AstUtils.getContainerOfType(el, ast.isElementView)
       if (isNullish(view?.viewOf)) {
         accept('warning', 'Predicate is ignored as it concerns all relationships', {
-          node: el
+          node: el,
         })
       }
     }
-  }
+  })
 }

package/src/validation/view-predicates/relation-with.ts

@@ -1,16 +1,17 @@
-import { AstUtils, type ValidationCheck } from 'langium'
+import { type ValidationCheck, AstUtils } from 'langium'
 import { ast } from '../../ast'
 import type { LikeC4Services } from '../../module'
+import { tryOrLog } from '../_shared'
 
 export const relationPredicateWithChecks = (
-  _services: LikeC4Services
+  _services: LikeC4Services,
 ): ValidationCheck<ast.RelationPredicateWith> => {
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     const container = AstUtils.getContainerOfType(el, ast.isViewRulePredicate)
     if (ast.isExcludePredicate(container)) {
       accept('error', 'Invalid usage inside "exclude"', {
-        node: el
+        node: el,
       })
     }
-  }
+  })
 }

package/src/validation/view.ts

@@ -1,11 +1,11 @@
 import { type ValidationCheck } from 'langium'
 import { ast } from '../ast'
 import type { LikeC4Services } from '../module'
-import { RESERVED_WORDS } from './_shared'
+import { RESERVED_WORDS, tryOrLog } from './_shared'
 
 export const viewChecks = (services: LikeC4Services): ValidationCheck<ast.LikeC4View> => {
   const index = services.shared.workspace.IndexManager
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     // const commentNode = CstUtils.findCommentNode(el.$cstNode, ['BLOCK_COMMENT'])
     // if (commentNode && hasManualLayout(commentNode.text) && !deserializeFromComment(commentNode.text)) {
     //   accept('warning', `Malformed @likec4-generated (ignored)`, {
@@ -19,7 +19,7 @@ export const viewChecks = (services: LikeC4Services): ValidationCheck<ast.LikeC4
     if (RESERVED_WORDS.includes(el.name)) {
       accept('error', `Reserved word: ${el.name}`, {
         node: el,
-        property: 'name'
+        property: 'name',
       })
     }
     const anotherViews = index
@@ -30,8 +30,8 @@ export const viewChecks = (services: LikeC4Services): ValidationCheck<ast.LikeC4
     if (anotherViews > 1) {
       accept('error', `Duplicate view '${el.name}'`, {
         node: el,
-        property: 'name'
+        property: 'name',
       })
     }
-  }
+  })
 }

package/src/view-utils/assignNavigateTo.ts

@@ -1,4 +1,4 @@
-import { ComputedNode, ComputedView, type Fqn, isElementView, type ViewId } from '@likec4/core'
+import { ComputedNode, ComputedView, type Fqn, type ViewId } from '@likec4/core'
 import { find, isNullish } from 'remeda'
 
 export function assignNavigateTo<R extends Iterable<ComputedView>>(views: R): R {