@likec4/language-server 1.21.1 → 1.22.1

package/src/validation/index.ts

@@ -1,171 +0,0 @@
-import { type AstNode, DocumentState } 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'
-import { dynamicViewRulePredicate } from './dynamic-view-rule'
-import { dynamicViewStep } from './dynamic-view-step'
-import { elementChecks } from './element'
-import { iconPropertyRuleChecks, notesPropertyRuleChecks, opacityPropertyRuleChecks } from './property-checks'
-import { relationBodyChecks, relationChecks } from './relation'
-import {
-  deploymentNodeKindChecks,
-  elementKindChecks,
-  globalPredicateChecks,
-  globalsChecks,
-  globalStyleIdChecks,
-  modelRuleChecks,
-  relationshipChecks,
-  specificationRuleChecks,
-  tagChecks,
-} from './specification'
-import { viewChecks } from './view'
-import {
-  elementPredicateWithChecks,
-  expandElementExprChecks,
-  fqnRefExprChecks,
-  incomingExpressionChecks,
-  outgoingExpressionChecks,
-  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.state >= DocumentState.Validated
-    ? (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.debug('registerValidationChecks')
-  const registry = services.validation.ValidationRegistry
-  registry.register<ast.LikeC4AstType>({
-    DeployedInstance: deployedInstanceChecks(services),
-    DeploymentNodeKind: deploymentNodeKindChecks(services),
-    DeploymentNode: deploymentNodeChecks(services),
-    DeploymentRelation: deploymentRelationChecks(services),
-    FqnRefExpr: fqnRefExprChecks(services),
-    RelationExpr: relationExprChecks(services),
-    NotesProperty: notesPropertyRuleChecks(services),
-    OpacityProperty: opacityPropertyRuleChecks(services),
-    IconProperty: iconPropertyRuleChecks(services),
-    SpecificationRule: specificationRuleChecks(services),
-    Model: modelRuleChecks(services),
-    Globals: globalsChecks(services),
-    GlobalPredicateGroup: globalPredicateChecks(services),
-    GlobalDynamicPredicateGroup: globalPredicateChecks(services),
-    GlobalStyleId: globalStyleIdChecks(services),
-    DynamicViewStep: dynamicViewStep(services),
-    LikeC4View: viewChecks(services),
-    Element: elementChecks(services),
-    ElementKind: elementKindChecks(services),
-    Relation: relationChecks(services),
-    RelationBody: relationBodyChecks(services),
-    Tag: tagChecks(services),
-    DynamicViewPredicateIterator: dynamicViewRulePredicate(services),
-    ElementPredicateWith: elementPredicateWithChecks(services),
-    RelationPredicateWith: relationPredicateWithChecks(services),
-    ExpandElementExpression: expandElementExprChecks(services),
-    RelationshipKind: relationshipChecks(services),
-    IncomingRelationExpression: incomingExpressionChecks(services),
-    OutgoingRelationExpression: outgoingExpressionChecks(services),
-  })
-  const connection = services.shared.lsp.Connection
-  if (connection) {
-    // workaround for bug in langium
-    services.shared.workspace.DocumentBuilder.onUpdate((_, deleted) => {
-      for (const uri of deleted) {
-        logger.debug(`clear diagnostics for deleted ${uri.path}`)
-        void connection.sendDiagnostics({
-          uri: uri.toString(),
-          diagnostics: [],
-        })
-      }
-    })
-  }
-}

package/src/validation/property-checks.ts

@@ -1,52 +0,0 @@
-import { type ValidationCheck, AstUtils } from 'langium'
-import { ast } from '../ast'
-import type { LikeC4Services } from '../module'
-import { tryOrLog } from './_shared'
-
-export const opacityPropertyRuleChecks = (
-  _: LikeC4Services,
-): ValidationCheck<ast.OpacityProperty> => {
-  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',
-      })
-    }
-  })
-}
-
-export const iconPropertyRuleChecks = (
-  _: 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,
-      })
-    }
-    if (
-      ast.isElementStyleProperty(container) && ast.isElementBody(container.$container)
-      && container.$container.props.some(p => ast.isIconProperty(p))
-    ) {
-      accept('warning', `Redundant as icon defined on element`, {
-        node,
-      })
-    }
-  }
-}
-
-export const notesPropertyRuleChecks = (
-  _: LikeC4Services,
-): ValidationCheck<ast.NotesProperty> => {
-  return (node, accept) => {
-    if (!AstUtils.hasContainerOfType(node, ast.isDynamicViewStep)) {
-      accept('error', `Notes can be defined only inside dynamic view`, {
-        node,
-      })
-    }
-  }
-}

package/src/validation/relation.ts

@@ -1,63 +0,0 @@
-import { isSameHierarchy } from '@likec4/core'
-import type { ValidationCheck } from 'langium'
-import { isDefined } from 'remeda'
-import { ast } from '../ast'
-import type { LikeC4Services } from '../module'
-import { elementRef } from '../utils/elementRef'
-import { tryOrLog } from './_shared'
-
-export const relationChecks = (services: LikeC4Services): ValidationCheck<ast.Relation> => {
-  const fqnIndex = services.likec4.FqnIndex
-  return tryOrLog((el, accept) => {
-    const targetEl: ast.Element | undefined = elementRef(el.target)
-    const target = targetEl && fqnIndex.getFqn(targetEl)
-    if (!target) {
-      accept('error', 'Target not resolved', {
-        node: el,
-        property: 'target'
-      })
-    }
-    let sourceEl
-    if (isDefined(el.source)) {
-      sourceEl = elementRef(el.source)
-      if (!sourceEl) {
-        return accept('error', 'Source not resolved', {
-          node: el,
-          property: 'source'
-        })
-      }
-    } else {
-      if (!ast.isElementBody(el.$container)) {
-        return accept('error', 'Sourceless relation must be nested', {
-          node: el
-        })
-      }
-      sourceEl = el.$container.$container
-    }
-
-    const source = fqnIndex.getFqn(sourceEl)
-
-    if (!source) {
-      accept('error', 'Source not resolved', {
-        node: el
-      })
-    }
-
-    if (source && target && isSameHierarchy(source, target)) {
-      accept('error', 'Invalid parent-child relationship', {
-        node: el
-      })
-    }
-  })
-}
-
-export const relationBodyChecks = (_services: LikeC4Services): ValidationCheck<ast.RelationBody> => {
-  return tryOrLog((body, accept) => {
-    const relation = body.$container
-    if (relation.tags?.values && body.tags?.values) {
-      accept('error', 'Relation cannot have tags in both header and body', {
-        node: body.tags
-      })
-    }
-  })
-}

package/src/validation/specification.ts

@@ -1,205 +0,0 @@
-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,
-): ValidationCheck<ast.SpecificationRule> => {
-  return tryOrLog((node, accept) => {
-    if (node.$containerIndex && node.$containerIndex > 0) {
-      accept('warning', `Prefer one specification per document`, {
-        node: node,
-        property: 'name',
-      })
-    }
-  })
-}
-
-export const modelRuleChecks = (_: LikeC4Services): ValidationCheck<ast.Model> => {
-  return tryOrLog((node, accept) => {
-    if (node.$containerIndex && node.$containerIndex > 0) {
-      accept('warning', `Prefer one model per document`, {
-        node: node,
-        property: 'name',
-      })
-    }
-  })
-}
-
-export const globalsChecks = (_: LikeC4Services): ValidationCheck<ast.Globals> => {
-  return tryOrLog((node, accept) => {
-    if (node.$containerIndex && node.$containerIndex > 0) {
-      accept('warning', `Prefer one global block per document`, {
-        node: node,
-        property: 'name',
-      })
-    }
-  })
-}
-
-export const elementKindChecks = (services: LikeC4Services): ValidationCheck<ast.ElementKind> => {
-  const index = services.shared.workspace.IndexManager
-  return tryOrLog((node, accept) => {
-    if (RESERVED_WORDS.includes(node.name)) {
-      accept('error', `Reserved word: ${node.name}`, {
-        node: node,
-        property: 'name',
-      })
-    }
-    const sameKind = index
-      .allElements(ast.ElementKind)
-      .filter(n => n.name === node.name && n.node !== node)
-      .head()
-    if (sameKind) {
-      const isAnotherDoc = sameKind.documentUri !== AstUtils.getDocument(node).uri
-      accept('error', `Duplicate element kind '${node.name}'`, {
-        node: node,
-        property: 'name',
-        ...isAnotherDoc && {
-          relatedInformation: [
-            {
-              location: {
-                range: sameKind.nameSegment!.range,
-                uri: sameKind.documentUri.toString(),
-              },
-              message: `conflicting definition`,
-            },
-          ],
-        },
-      })
-    }
-  })
-}
-
-export const deploymentNodeKindChecks = (services: LikeC4Services): ValidationCheck<ast.DeploymentNodeKind> => {
-  const index = services.shared.workspace.IndexManager
-  return tryOrLog((node, accept) => {
-    if (RESERVED_WORDS.includes(node.name)) {
-      accept('error', `Reserved word: ${node.name}`, {
-        node: node,
-        property: 'name',
-      })
-    }
-    const sameKind = index
-      .allElements(ast.DeploymentNodeKind)
-      .filter(n => n.name === node.name && n.node !== node)
-      .head()
-    if (sameKind) {
-      const isAnotherDoc = sameKind.documentUri !== AstUtils.getDocument(node).uri
-      accept('error', `Duplicate deploymentNode kind '${node.name}'`, {
-        node: node,
-        property: 'name',
-        ...isAnotherDoc && {
-          relatedInformation: [
-            {
-              location: {
-                range: sameKind.nameSegment!.range,
-                uri: sameKind.documentUri.toString(),
-              },
-              message: `conflicting definition`,
-            },
-          ],
-        },
-      })
-    }
-  })
-}
-
-export const tagChecks = (services: LikeC4Services): ValidationCheck<ast.Tag> => {
-  const index = services.shared.workspace.IndexManager
-  return tryOrLog((node, accept) => {
-    const tagname = '#' + node.name
-    const sameTag = index
-      .allElements(ast.Tag)
-      .filter(n => n.name === tagname && n.node !== node)
-      .head()
-    if (sameTag) {
-      const isAnotherDoc = sameTag.documentUri !== AstUtils.getDocument(node).uri
-      accept(
-        'error',
-        `Duplicate tag '${node.name}'`,
-        {
-          node,
-          property: 'name',
-          ...isAnotherDoc && {
-            relatedInformation: [
-              {
-                location: {
-                  range: sameTag.nameSegment!.range,
-                  uri: sameTag.documentUri.toString(),
-                },
-                message: `conflicting definition`,
-              },
-            ],
-          },
-        },
-      )
-    }
-  })
-}
-
-export const relationshipChecks = (
-  services: LikeC4Services,
-): ValidationCheck<ast.RelationshipKind> => {
-  const index = services.shared.workspace.IndexManager
-  return tryOrLog((node, accept) => {
-    if (RESERVED_WORDS.includes(node.name)) {
-      accept('error', `Reserved word: ${node.name}`, {
-        node: node,
-        property: 'name',
-      })
-    }
-    const sameKinds = index
-      .allElements(ast.RelationshipKind)
-      .filter(n => n.name === node.name)
-      .limit(2)
-      .count()
-    if (sameKinds > 1) {
-      accept('error', `Duplicate RelationshipKind '${node.name}'`, {
-        node: node,
-        property: 'name',
-      })
-    }
-  })
-}
-
-export const globalPredicateChecks = (
-  services: LikeC4Services,
-): ValidationCheck<ast.GlobalPredicateGroup | ast.GlobalDynamicPredicateGroup> => {
-  const index = services.shared.workspace.IndexManager
-  return tryOrLog((node, accept) => {
-    const predicateGroups = index.allElements(ast.GlobalPredicateGroup)
-    const dynamicPredicateGroups = index.allElements(ast.GlobalDynamicPredicateGroup)
-    const sameName = predicateGroups
-      .concat(dynamicPredicateGroups)
-      .filter(s => s.name === node.name)
-      .limit(2)
-      .count()
-    if (sameName > 1) {
-      accept('error', `Duplicate GlobalPredicateGroup or GlobalDynamicPredicateGroup name '${node.name}'`, {
-        node: node,
-        property: 'name',
-      })
-    }
-  })
-}
-
-export const globalStyleIdChecks = (
-  services: LikeC4Services,
-): ValidationCheck<ast.GlobalStyleId> => {
-  const index = services.shared.workspace.IndexManager
-  return tryOrLog((node, accept) => {
-    const sameName = index
-      .allElements(ast.GlobalStyleId)
-      .filter(s => s.name === node.name)
-      .limit(2)
-      .count()
-    if (sameName > 1) {
-      accept('error', `Duplicate GlobalStyleId name '${node.name}'`, {
-        node: node,
-        property: 'name',
-      })
-    }
-  })
-}

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

@@ -1,36 +0,0 @@
-import { nonexhaustive } from '@likec4/core'
-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,
-): ValidationCheck<ast.ElementPredicateWith> => {
-  return tryOrLog((el, accept) => {
-    const container = AstUtils.getContainerOfType(el, ast.isViewRulePredicate)
-    if (ast.isExcludePredicate(container)) {
-      accept('error', 'Invalid usage inside "exclude"', {
-        node: el,
-      })
-    }
-    const subject = ast.isElementPredicateWhere(el.subject) ? el.subject.subject : el.subject
-    switch (true) {
-      case ast.isElementRef(subject):
-      case ast.isElementDescedantsExpression(subject):
-      case ast.isExpandElementExpression(subject):
-      case ast.isWildcardExpression(subject):
-        return
-      case ast.isElementKindExpression(subject):
-      case ast.isElementTagExpression(subject):
-        accept('error', 'Invalid target (expect reference to specific element)', {
-          node: el,
-          property: 'subject',
-        })
-        return
-      default:
-        nonexhaustive(subject)
-    }
-  })
-}

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

@@ -1,16 +0,0 @@
-import { type ValidationCheck, AstUtils } from 'langium'
-import { ast } from '../../ast'
-import type { LikeC4Services } from '../../module'
-import { tryOrLog } from '../_shared'
-
-export const expandElementExprChecks = (
-  _services: LikeC4Services,
-): ValidationCheck<ast.ExpandElementExpression> => {
-  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,
-      })
-    }
-  })
-}

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

@@ -1,101 +0,0 @@
-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,20 +0,0 @@
-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,
-): ValidationCheck<ast.IncomingRelationExpression> => {
-  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,
-        })
-      }
-    }
-  })
-}

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

@@ -1,6 +0,0 @@
-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,20 +0,0 @@
-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,
-): ValidationCheck<ast.OutgoingRelationExpression> => {
-  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,
-        })
-      }
-    }
-  })
-}