@likec4/language-server 1.42.1 → 1.44.0

package/dist/validation/imports.mjs

@@ -1,25 +0,0 @@
-import { AstUtils } from "langium";
-import { projectIdFrom } from "../utils/index.mjs";
-import { tryOrLog } from "./_shared.mjs";
-const { getDocument } = AstUtils;
-export const checkImportsFromPoject = (services) => {
-  const projects = services.shared.workspace.ProjectsManager;
-  return tryOrLog((el, accept) => {
-    const doc = getDocument(el);
-    const projectId = projectIdFrom(doc);
-    if (el.project === projectId) {
-      accept("error", "Imported project cannot be the same as the current project", {
-        node: el,
-        property: "project"
-      });
-      return;
-    }
-    if (!projects.all.includes(el.project)) {
-      accept("error", "Imported project not found", {
-        node: el,
-        property: "project"
-      });
-      return;
-    }
-  });
-};

package/dist/validation/index.mjs

@@ -1,180 +0,0 @@
-import { onNextTick } from "@likec4/core/utils";
-import { loggable } from "@likec4/log";
-import { DocumentState } from "langium";
-import { isNullish } from "remeda";
-import { DiagnosticSeverity } from "vscode-languageserver-types";
-import { ast } from "../ast.mjs";
-import { logger } from "../logger.mjs";
-import {
-  deployedInstanceChecks,
-  deploymentNodeChecks,
-  deploymentRelationChecks,
-  extendDeploymentChecks
-} from "./deployment-checks.mjs";
-import { dynamicViewDisplayVariant, dynamicViewStepChain, dynamicViewStepSingle } from "./dynamic-view.mjs";
-import { checkElement } from "./element.mjs";
-import { checkElementRef } from "./element-ref.mjs";
-import { checkImportsFromPoject } from "./imports.mjs";
-import {
-  colorLiteralRuleChecks,
-  iconPropertyRuleChecks,
-  notesPropertyRuleChecks,
-  opacityPropertyRuleChecks
-} from "./property-checks.mjs";
-import { checkRelationBody, relationChecks } from "./relation.mjs";
-import {
-  checkDeploymentNodeKind,
-  checkElementKind,
-  checkGlobalPredicate,
-  checkGlobals,
-  checkGlobalStyleId,
-  checkModel,
-  checkRelationshipKind,
-  checkSpecificationRule,
-  checkTag
-} from "./specification.mjs";
-import { viewChecks } from "./view.mjs";
-import {
-  checkFqnExprWith,
-  checkFqnRefExpr,
-  checkIncomingRelationExpr,
-  checkOutgoingRelationExpr,
-  checkRelationExpr,
-  checkRelationExprWith
-} from "./view-predicates/index.mjs";
-export { LikeC4DocumentValidator } from "./DocumentValidator.mjs";
-function validatableAstNodeGuards(predicates) {
-  return (n) => predicates.some((p) => p(n));
-}
-const isValidatableAstNode = validatableAstNodeGuards([
-  ast.isImportsFromPoject,
-  ast.isImported,
-  ast.isGlobals,
-  ast.isGlobalPredicateGroup,
-  ast.isGlobalDynamicPredicateGroup,
-  ast.isGlobalStyle,
-  ast.isGlobalStyleGroup,
-  ast.isFqnExprWith,
-  ast.isRelationExprWith,
-  ast.isFqnExpr,
-  ast.isRelationExpr,
-  ast.isDynamicViewParallelSteps,
-  ast.isDynamicStepChain,
-  ast.isDynamicStepSingle,
-  ast.isDeploymentViewRule,
-  ast.isDeploymentViewRulePredicate,
-  ast.isExpressionV2,
-  ast.isRelationExpr,
-  ast.isFqnRefExpr,
-  ast.isViewProperty,
-  ast.isStyleProperty,
-  ast.isTags,
-  ast.isViewRule,
-  ast.isDynamicViewRule,
-  ast.isLikeC4View,
-  ast.isViewRuleStyleOrGlobalRef,
-  ast.isDeployedInstance,
-  ast.isDeploymentNode,
-  ast.isDeploymentRelation,
-  ast.isRelationshipStyleProperty,
-  ast.isDynamicViewDisplayVariantProperty,
-  ast.isMetadataProperty,
-  ast.isRelation,
-  ast.isElementProperty,
-  ast.isStringProperty,
-  ast.isNavigateToProperty,
-  ast.isElement,
-  ast.isElementRef,
-  ast.isExtendElement,
-  ast.isExtendDeployment,
-  ast.isSpecificationElementKind,
-  ast.isSpecificationRelationshipKind,
-  ast.isSpecificationDeploymentNodeKind,
-  ast.isSpecificationTag,
-  ast.isSpecificationColor,
-  ast.isSpecificationRule,
-  ast.isColorLiteral
-]);
-const findInvalidContainer = (node) => {
-  let nd = node;
-  while (nd && !ast.isLikeC4Grammar(nd)) {
-    if (isValidatableAstNode(nd)) {
-      return nd;
-    }
-    nd = nd.$container;
-  }
-  return void 0;
-};
-export function checksFromDiagnostics(doc) {
-  const errors = doc.state >= DocumentState.Validated ? doc.diagnostics?.filter((d) => d.severity === DiagnosticSeverity.Error) ?? [] : [];
-  const invalidNodes = /* @__PURE__ */ 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) => !invalidNodes.has(n);
-  return {
-    isValid,
-    invalidNodes
-  };
-}
-export function registerValidationChecks(services) {
-  logger.debug("registerValidationChecks");
-  const registry = services.validation.ValidationRegistry;
-  registry.register({
-    DeployedInstance: deployedInstanceChecks(services),
-    DeploymentNodeKind: checkDeploymentNodeKind(services),
-    DeploymentNode: deploymentNodeChecks(services),
-    DeploymentRelation: deploymentRelationChecks(services),
-    ExtendDeployment: extendDeploymentChecks(services),
-    FqnRefExpr: checkFqnRefExpr(services),
-    RelationExpr: checkRelationExpr(services),
-    NotesProperty: notesPropertyRuleChecks(services),
-    OpacityProperty: opacityPropertyRuleChecks(services),
-    IconProperty: iconPropertyRuleChecks(services),
-    SpecificationRule: checkSpecificationRule(services),
-    Model: checkModel(services),
-    Globals: checkGlobals(services),
-    GlobalPredicateGroup: checkGlobalPredicate(services),
-    GlobalDynamicPredicateGroup: checkGlobalPredicate(services),
-    GlobalStyleId: checkGlobalStyleId(services),
-    DynamicStepSingle: dynamicViewStepSingle(services),
-    DynamicStepChain: dynamicViewStepChain(services),
-    LikeC4View: viewChecks(services),
-    Element: checkElement(services),
-    ElementRef: checkElementRef(services),
-    ElementKind: checkElementKind(services),
-    Relation: relationChecks(services),
-    RelationBody: checkRelationBody(services),
-    Tag: checkTag(services),
-    FqnExprWith: checkFqnExprWith(services),
-    RelationExprWith: checkRelationExprWith(services),
-    RelationshipKind: checkRelationshipKind(services),
-    IncomingRelationExpr: checkIncomingRelationExpr(services),
-    OutgoingRelationExpr: checkOutgoingRelationExpr(services),
-    ImportsFromPoject: checkImportsFromPoject(services),
-    // Imported: checkImported(services),
-    ColorLiteral: colorLiteralRuleChecks(services),
-    DynamicViewDisplayVariantProperty: dynamicViewDisplayVariant(services)
-  });
-  const connection = services.shared.lsp.Connection;
-  if (connection) {
-    onNextTick(() => {
-      services.shared.workspace.DocumentBuilder.onUpdate((_, deleted) => {
-        for (const uri of deleted) {
-          logger.debug(`clear diagnostics for deleted ${uri.path}`);
-          connection.sendDiagnostics({
-            uri: uri.toString(),
-            diagnostics: []
-          }).catch((e) => logger.error(loggable(e)));
-        }
-      });
-    });
-  }
-}

package/dist/validation/property-checks.mjs

@@ -1,107 +0,0 @@
-import { nonexhaustive } from "@likec4/core";
-import { AstUtils } from "langium";
-import { isNumber, isString } from "remeda";
-import { ast } from "../ast.mjs";
-import { tryOrLog } from "./_shared.mjs";
-export const opacityPropertyRuleChecks = (_) => {
-  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 = (_) => {
-  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
-      });
-    }
-    if (node.value?.startsWith("file://")) {
-      accept("error", `Icon URI must not start with file://`, {
-        node,
-        property: "value"
-      });
-    }
-  };
-};
-export const notesPropertyRuleChecks = (_) => {
-  return (node, accept) => {
-    if (!AstUtils.hasContainerOfType(node, ast.isDynamicViewStep)) {
-      accept("error", `Notes can be defined only inside dynamic view`, {
-        node
-      });
-    }
-  };
-};
-export const colorLiteralRuleChecks = (_) => {
-  return (node, accept) => {
-    if (node.$type === "HexColor") {
-      if (node.hex === void 0 || isString(node.hex) && !node.hex.match(/^[a-fA-F0-9]+$/)) {
-        accept("error", `Invalid HEX`, {
-          node,
-          property: "hex"
-        });
-        return;
-      }
-      const length = isNumber(node.hex) ? node.hex.toString().length : node.hex.length;
-      if (length !== 6 && length !== 3 && length !== 8) {
-        accept("error", `Invalid value "${node.$cstNode?.text}", must be 3, 6 or 8 characters long`, {
-          node,
-          property: "hex"
-        });
-      }
-      return;
-    }
-    if (node.$type === "RGBAColor") {
-      if (!isNumber(node.red) || node.red < 0 || node.red > 255) {
-        accept("error", `Invalid value, must be between 0 and 255`, {
-          node,
-          property: "red"
-        });
-      }
-      if (!isNumber(node.green) || node.green < 0 || node.green > 255) {
-        accept("error", `Invalid value, must be between 0 and 255`, {
-          node,
-          property: "green"
-        });
-      }
-      if (!isNumber(node.blue) || node.blue < 0 || node.blue > 255) {
-        accept("error", `Invalid value, must be between 0 and 255`, {
-          node,
-          property: "blue"
-        });
-      }
-      if (isNumber(node.alpha)) {
-        if (node.alpha < 0 || node.alpha > 1) {
-          accept("error", `Invalid value, must be between 0 and 1`, {
-            node,
-            property: "alpha"
-          });
-        }
-      }
-      if (isString(node.alpha)) {
-        const alpha = parseFloat(node.alpha);
-        if (alpha < 0 || alpha > 100) {
-          accept("error", `Invalid value, must be between 0% and 100%`, {
-            node,
-            property: "alpha"
-          });
-        }
-      }
-      return;
-    }
-    nonexhaustive(node);
-  };
-};

package/dist/validation/relation.mjs

@@ -1,53 +0,0 @@
-import { FqnRef, isSameHierarchy } from "@likec4/core";
-import { AstUtils } from "langium";
-import { safeCall } from "../utils/index.mjs";
-import { tryOrLog } from "./_shared.mjs";
-export const relationChecks = (services) => {
-  const modelParser = services.likec4.ModelParser;
-  return tryOrLog((el, accept) => {
-    const parser = modelParser.forDocument(AstUtils.getDocument(el));
-    const source = safeCall(() => parser._resolveRelationSource(el));
-    if (!source) {
-      accept("error", "Source not resolved", {
-        node: el,
-        property: "source"
-      });
-      return;
-    }
-    const target = safeCall(() => parser.parseFqnRef(el.target));
-    if (!target) {
-      accept("error", "Target not resolved", {
-        node: el,
-        property: "target"
-      });
-      return;
-    }
-    if (FqnRef.isImportRef(source)) {
-      if (FqnRef.isImportRef(target)) {
-        accept("warning", "Relationship between imported elements may not be visible in origin projects", {
-          node: el
-        });
-      } else {
-        accept("warning", "Relationship from imported element to local element may not be visible in origin project", {
-          node: el,
-          property: "source"
-        });
-      }
-    }
-    if (isSameHierarchy(FqnRef.flatten(source), FqnRef.flatten(target))) {
-      accept("error", "Invalid parent-child relationship", {
-        node: el
-      });
-    }
-  });
-};
-export const checkRelationBody = (_services) => {
-  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/dist/validation/specification.mjs

@@ -1,173 +0,0 @@
-import { AstUtils } from "langium";
-import { ast } from "../ast.mjs";
-import { projectIdFrom } from "../utils/index.mjs";
-import { RESERVED_WORDS, tryOrLog } from "./_shared.mjs";
-export const checkSpecificationRule = (_) => {
-  return tryOrLog((node, accept) => {
-    if (node.$containerIndex && node.$containerIndex > 0) {
-      accept("warning", `Prefer one specification per document`, {
-        node,
-        property: "name"
-      });
-    }
-  });
-};
-export const checkModel = (_) => {
-  return tryOrLog((node, accept) => {
-    if (node.$containerIndex && node.$containerIndex > 0) {
-      accept("warning", `Prefer one model per document`, {
-        node,
-        property: "name"
-      });
-    }
-  });
-};
-export const checkGlobals = (_) => {
-  return tryOrLog((node, accept) => {
-    if (node.$containerIndex && node.$containerIndex > 0) {
-      accept("warning", `Prefer one global block per document`, {
-        node,
-        property: "name"
-      });
-    }
-  });
-};
-export const checkElementKind = (services) => {
-  const index = services.shared.workspace.IndexManager;
-  return tryOrLog((node, accept) => {
-    if (RESERVED_WORDS.includes(node.name)) {
-      accept("error", `Reserved word: ${node.name}`, {
-        node,
-        property: "name"
-      });
-    }
-    const projectId = projectIdFrom(node);
-    const sameKind = index.projectElements(projectId, 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,
-        property: "name",
-        ...isAnotherDoc && {
-          relatedInformation: [
-            {
-              location: {
-                range: sameKind.nameSegment.range,
-                uri: sameKind.documentUri.toString()
-              },
-              message: `conflicting definition`
-            }
-          ]
-        }
-      });
-    }
-  });
-};
-export const checkDeploymentNodeKind = (services) => {
-  const index = services.shared.workspace.IndexManager;
-  return tryOrLog((node, accept) => {
-    if (RESERVED_WORDS.includes(node.name)) {
-      accept("error", `Reserved word: ${node.name}`, {
-        node,
-        property: "name"
-      });
-    }
-    const projectId = projectIdFrom(node);
-    const sameKind = index.projectElements(projectId, 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,
-        property: "name",
-        ...isAnotherDoc && {
-          relatedInformation: [
-            {
-              location: {
-                range: sameKind.nameSegment.range,
-                uri: sameKind.documentUri.toString()
-              },
-              message: `conflicting definition`
-            }
-          ]
-        }
-      });
-    }
-  });
-};
-export const checkTag = (services) => {
-  const index = services.shared.workspace.IndexManager;
-  return tryOrLog((node, accept) => {
-    const tagname = node.name;
-    const projectId = projectIdFrom(node);
-    const sameTag = index.projectElements(projectId, 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 checkRelationshipKind = (services) => {
-  const index = services.shared.workspace.IndexManager;
-  return tryOrLog((node, accept) => {
-    if (RESERVED_WORDS.includes(node.name)) {
-      accept("error", `Reserved word: ${node.name}`, {
-        node,
-        property: "name"
-      });
-    }
-    const projectId = projectIdFrom(node);
-    const sameKinds = index.projectElements(projectId, ast.RelationshipKind).filter((n) => n.name === node.name).limit(2).count();
-    if (sameKinds > 1) {
-      accept("error", `Duplicate RelationshipKind '${node.name}'`, {
-        node,
-        property: "name"
-      });
-    }
-  });
-};
-export const checkGlobalPredicate = (services) => {
-  const index = services.shared.workspace.IndexManager;
-  return tryOrLog((node, accept) => {
-    const projectId = projectIdFrom(node);
-    const predicateGroups = index.projectElements(projectId, ast.GlobalPredicateGroup);
-    const dynamicPredicateGroups = index.projectElements(projectId, 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,
-        property: "name"
-      });
-    }
-  });
-};
-export const checkGlobalStyleId = (services) => {
-  const index = services.shared.workspace.IndexManager;
-  return tryOrLog((node, accept) => {
-    const projectId = projectIdFrom(node);
-    const sameName = index.projectElements(projectId, ast.GlobalStyleId).filter((s) => s.name === node.name).limit(2).count();
-    if (sameName > 1) {
-      accept("error", `Duplicate GlobalStyleId name '${node.name}'`, {
-        node,
-        property: "name"
-      });
-    }
-  });
-};

package/dist/validation/view-predicates/fqn-expr-with.mjs

@@ -1,43 +0,0 @@
-import { FqnExpr } from "@likec4/core/types";
-import { nonexhaustive } from "@likec4/core/utils";
-import { AstUtils } from "langium";
-import { getViewRulePredicateContainer } from "../../ast.mjs";
-import { tryOrLog } from "../_shared.mjs";
-export const checkFqnExprWith = (services) => {
-  const modelParser = services.likec4.ModelParser;
-  return tryOrLog((el, accept) => {
-    const container = getViewRulePredicateContainer(el);
-    if (container?.$type !== "DynamicViewIncludePredicate" && container?.isInclude !== true) {
-      accept("error", 'Invalid usage inside "exclude"', {
-        node: el
-      });
-      return;
-    }
-    const isInsideDynamicView = container.$type === "DynamicViewIncludePredicate";
-    const parser = modelParser.forDocument(AstUtils.getDocument(container));
-    let expr = FqnExpr.unwrap(parser.parseFqnExprWith(el).custom.expr);
-    switch (true) {
-      case (FqnExpr.isWildcard(expr) && isInsideDynamicView):
-      case (FqnExpr.isElementKindExpr(expr) && isInsideDynamicView):
-      case (FqnExpr.isElementTagExpr(expr) && isInsideDynamicView): {
-        accept("warning", `Predicate is ignored, as not supported in dynamic views`, {
-          node: el
-        });
-        return;
-      }
-      case FqnExpr.isWildcard(expr):
-      case FqnExpr.isModelRef(expr):
-      case FqnExpr.isDeploymentRef(expr):
-        return;
-      case FqnExpr.isElementKindExpr(expr):
-      case FqnExpr.isElementTagExpr(expr):
-        accept("error", "Invalid target (expect reference to specific element)", {
-          node: el,
-          property: "subject"
-        });
-        return;
-      default:
-        nonexhaustive(expr);
-    }
-  });
-};

package/dist/validation/view-predicates/fqn-ref-expr.mjs

@@ -1,53 +0,0 @@
-import { FqnExpr, FqnRef } from "@likec4/core/types";
-import { AstUtils } from "langium";
-import { isTruthy } from "remeda";
-import { ast, getViewRulePredicateContainer, isFqnRefInsideDeployment } from "../../ast.mjs";
-import { tryOrLog } from "../_shared.mjs";
-export const checkFqnRefExpr = (services) => {
-  const modelParser = services.likec4.ModelParser;
-  return tryOrLog((node, accept) => {
-    const parser = modelParser.forDocument(AstUtils.getDocument(node));
-    const expr = parser.parseFqnRefExpr(node);
-    const viewRulePredicate = getViewRulePredicateContainer(node);
-    const isInsideDeploymentButNotStyle = isFqnRefInsideDeployment(node) && !AstUtils.hasContainerOfType(
-      node,
-      (n) => ast.isDeploymentViewRuleStyle(n) || ast.isViewRuleStyle(n)
-    );
-    if (viewRulePredicate?.$type === "DeploymentViewRulePredicate" || isInsideDeploymentButNotStyle) {
-      const isPartOfRelationExpr = AstUtils.hasContainerOfType(node, ast.isRelationExpr);
-      if (!isPartOfRelationExpr) {
-        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 (isTruthy(node.selector) && !ast.isDeploymentNode(node.ref.value?.ref)) {
-        accept("warning", `Selector '${node.selector}' applies to deployment nodes only, ignored here`, {
-          node,
-          property: "selector"
-        });
-      }
-      return;
-    }
-    if (viewRulePredicate?.$type === "DynamicViewIncludePredicate") {
-      switch (true) {
-        case FqnExpr.isElementKindExpr(expr):
-        case FqnExpr.isElementTagExpr(expr):
-        case FqnExpr.isWildcard(expr): {
-          accept("warning", `Predicate is ignored, as not supported in dynamic views`, {
-            node
-          });
-          return;
-        }
-      }
-    }
-  });
-};

package/dist/validation/view-predicates/incoming.mjs

@@ -1,16 +0,0 @@
-import { AstUtils } from "langium";
-import { isNullish } from "remeda";
-import { ast } from "../../ast.mjs";
-import { tryOrLog } from "../_shared.mjs";
-export const checkIncomingRelationExpr = (_services) => {
-  return tryOrLog((el, accept) => {
-    if (el.to.$type === "WildcardExpression" && !ast.isInOutRelationExpr(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/dist/validation/view-predicates/index.mjs

@@ -1,6 +0,0 @@
-export { checkFqnExprWith } from "./fqn-expr-with.mjs";
-export { checkFqnRefExpr } from "./fqn-ref-expr.mjs";
-export { checkIncomingRelationExpr } from "./incoming.mjs";
-export { checkOutgoingRelationExpr } from "./outgoing.mjs";
-export { checkRelationExpr } from "./relation-expr.mjs";
-export { checkRelationExprWith } from "./relation-with.mjs";

package/dist/validation/view-predicates/outgoing.mjs

@@ -1,20 +0,0 @@
-import { AstUtils } from "langium";
-import { isNullish } from "remeda";
-import { ast, getViewRulePredicateContainer } from "../../ast.mjs";
-import { tryOrLog } from "../_shared.mjs";
-export const checkOutgoingRelationExpr = (_services) => {
-  return tryOrLog((el, accept) => {
-    const viewRulePredicate = getViewRulePredicateContainer(el);
-    if (viewRulePredicate?.$type !== "ViewRulePredicate") {
-      return;
-    }
-    if (el.$container.$type !== "DirectedRelationExpr" && el.from.$type === "WildcardExpression") {
-      const view = AstUtils.getContainerOfType(el, ast.isElementView);
-      if (view && isNullish(view.viewOf)) {
-        accept("warning", "Predicate is ignored as it concerns all relationships", {
-          node: el
-        });
-      }
-    }
-  });
-};