@likec4/language-server 1.27.2 → 1.28.0

package/dist/workspace/IndexManager.js

@@ -1,17 +1,18 @@
 import { DefaultIndexManager, stream } from "langium";
 import { CancellationToken } from "vscode-jsonrpc";
 export class IndexManager extends DefaultIndexManager {
-  projects;
   constructor(services) {
     super(services);
-    this.projects = services.workspace.ProjectsManager;
+    this.services = services;
   }
   async updateContent(document, cancelToken = CancellationToken.None) {
-    document.likec4ProjectId = this.projects.belongsTo(document.uri);
+    const projects = this.services.workspace.ProjectsManager;
+    document.likec4ProjectId = projects.belongsTo(document.uri);
     await super.updateContent(document, cancelToken);
   }
   projectElements(projectId, nodeType, uris) {
+    const projects = this.services.workspace.ProjectsManager;
     let documentUris = stream(this.symbolIndex.keys());
-    return documentUris.filter((uri) => this.projects.belongsTo(uri) === projectId && (!uris || uris.has(uri))).flatMap((uri) => this.getFileDescriptions(uri, nodeType));
+    return documentUris.filter((uri) => projects.belongsTo(uri) === projectId && (!uris || uris.has(uri))).flatMap((uri) => this.getFileDescriptions(uri, nodeType));
   }
 }

package/dist/workspace/LangiumDocuments.d.ts

@@ -3,7 +3,7 @@ import { type Stream, DefaultLangiumDocuments } from 'langium';
 import { type LikeC4LangiumDocument } from '../ast';
 import type { LikeC4SharedServices } from '../module';
 export declare class LangiumDocuments extends DefaultLangiumDocuments {
-    private projects;
+    protected services: LikeC4SharedServices;
     constructor(services: LikeC4SharedServices);
     /**
      * Returns all user documents, excluding built-in documents.

package/dist/workspace/LangiumDocuments.js

@@ -3,22 +3,20 @@ import { groupBy, prop } from "remeda";
 import { isLikeC4LangiumDocument } from "../ast.js";
 import { isLikeC4Builtin } from "../likec4lib.js";
 export class LangiumDocuments extends DefaultLangiumDocuments {
-  projects;
   constructor(services) {
     super(services);
-    this.projects = services.workspace.ProjectsManager;
+    this.services = services;
   }
   /**
    * Returns all user documents, excluding built-in documents.
    */
   get allExcludingBuiltin() {
+    const projects = this.services.workspace.ProjectsManager;
     return super.all.filter((doc) => {
       if (!isLikeC4LangiumDocument(doc) || isLikeC4Builtin(doc.uri)) {
         return false;
       }
-      if (!doc.likec4ProjectId) {
-        doc.likec4ProjectId = this.projects.belongsTo(doc.uri);
-      }
+      doc.likec4ProjectId ??= projects.belongsTo(doc.uri);
       return true;
     });
   }

package/dist/workspace/ProjectsManager.d.ts

@@ -1,7 +1,14 @@
 import type { NonEmptyReadonlyArray, ProjectId } from '@likec4/core';
 import { type FileSystemNode, type LangiumDocument, URI, WorkspaceCache } from 'langium';
+import picomatch from 'picomatch/posix';
 import { ProjectConfig } from '../config';
 import type { LikeC4SharedServices } from '../module';
+interface Project {
+    id: ProjectId;
+    config: ProjectConfig;
+    folder: string;
+    exclude?: picomatch.Matcher;
+}
 export declare class ProjectsManager {
     protected services: LikeC4SharedServices;
     /**
@@ -14,35 +21,46 @@ export declare class ProjectsManager {
      * The mapping between project config files and project IDs.
      */
     private projectIdToFolder;
-    private _mappingsToProject;
     /**
      * Registered projects.
      * Sorted descending by the number of segments in the folder path.
      * This ensures that the most specific project is used for a document.
      */
     private _projects;
+    private defaultGlobalProject;
     constructor(services: LikeC4SharedServices);
+    /**
+     * Returns:
+     *  - the default project ID if there are no projects.
+     *  - the ID of the only project
+     *  - undefined if there are multiple projects.
+     */
     get defaultProjectId(): ProjectId | undefined;
     get all(): NonEmptyReadonlyArray<ProjectId>;
-    getProject(projectId: ProjectId): {
+    getProject(arg: ProjectId | LangiumDocument): {
+        id: ProjectId;
         folder: URI;
         config: Readonly<ProjectConfig>;
     };
     ensureProjectId(projectId?: ProjectId | undefined): ProjectId;
     hasMultipleProjects(): boolean;
+    checkIfExcluded(documentUri: URI): boolean;
+    isConfigFile(entry: FileSystemNode): boolean;
     /**
      * Checks if the provided file system entry is a valid project config file.
      *
      * @param entry The file system entry to check
      * @returns {boolean} Returns true if the entry is a valid config file, false otherwise.
      */
-    loadConfigFile(entry: FileSystemNode): Promise<boolean>;
-    registerProject(configFile: URI): Promise<void>;
+    loadConfigFile(entry: FileSystemNode): Promise<Project | undefined>;
+    registerProject(configFile: URI): Promise<Project>;
     registerProject(opts: {
         config: ProjectConfig;
         folderUri: URI | string;
-    }): Promise<void>;
+    }): Promise<Project>;
     belongsTo(document: LangiumDocument | URI | string): ProjectId;
-    private getProjectId;
-    protected get mappingsToProject(): WorkspaceCache<string, ProjectId>;
+    protected findProjectForDocument(documentUri: string): Omit<Project, 'folder'>;
+    private _mappingsToProject;
+    protected get mappingsToProject(): WorkspaceCache<string, Omit<Project, 'folder'>>;
 }
+export {};

package/dist/workspace/ProjectsManager.js

@@ -1,7 +1,14 @@
 import { BiMap, invariant, nonNullable } from "@likec4/core";
 import { URI, WorkspaceCache } from "langium";
-import { hasAtLeast, map, pipe, prop, sortBy } from "remeda";
-import { hasProtocol, joinRelativeURL, parseFilename, withoutProtocol, withProtocol } from "ufo";
+import picomatch from "picomatch/posix";
+import { hasAtLeast, isNullish, map, pipe, prop, sortBy } from "remeda";
+import {
+  hasProtocol,
+  joinRelativeURL,
+  parseFilename,
+  withoutProtocol,
+  withProtocol
+} from "ufo";
 import { parseConfigJson } from "../config/index.js";
 import { logger as mainLogger } from "../logger.js";
 const logger = mainLogger.getChild("ProjectsManager");
@@ -24,14 +31,26 @@ export class ProjectsManager {
    * The mapping between project config files and project IDs.
    */
   projectIdToFolder = new BiMap();
-  // The mapping between document URIs and their corresponding project IDs.
-  _mappingsToProject;
   /**
    * Registered projects.
    * Sorted descending by the number of segments in the folder path.
    * This ensures that the most specific project is used for a document.
    */
   _projects = [];
+  defaultGlobalProject = {
+    id: ProjectsManager.DefaultProjectId,
+    config: {
+      name: ProjectsManager.DefaultProjectId,
+      exclude: ["**/node_modules/**/*"]
+    },
+    exclude: picomatch("**/node_modules/**/*")
+  };
+  /**
+   * Returns:
+   *  - the default project ID if there are no projects.
+   *  - the ID of the only project
+   *  - undefined if there are multiple projects.
+   */
   get defaultProjectId() {
     if (this._projects.length > 1) {
       return void 0;
@@ -47,20 +66,24 @@ export class ProjectsManager {
     }
     return [ProjectsManager.DefaultProjectId];
   }
-  getProject(projectId) {
-    if (projectId === ProjectsManager.DefaultProjectId) {
-      const folder = this.services.workspace.WorkspaceManager.workspaceUri;
+  getProject(arg) {
+    const id = typeof arg === "string" ? arg : arg.likec4ProjectId || this.belongsTo(arg);
+    if (id === ProjectsManager.DefaultProjectId) {
+      const folder2 = this.services.workspace.WorkspaceManager.workspaceUri;
       return {
-        folder,
-        config: {
-          name: ProjectsManager.DefaultProjectId
-        }
+        id,
+        folder: folder2,
+        config: this.defaultGlobalProject.config
       };
     }
-    const project = nonNullable(this._projects.find(({ id }) => id === projectId), `Project "${projectId}" not found`);
+    const {
+      config,
+      folder
+    } = nonNullable(this._projects.find((p) => p.id === id), `Project "${id}" not found`);
     return {
-      folder: URI.parse(project.folder),
-      config: project.config
+      id,
+      folder: URI.parse(folder),
+      config
     };
   }
   ensureProjectId(projectId) {
@@ -79,6 +102,15 @@ export class ProjectsManager {
   hasMultipleProjects() {
     return this._projects.length > 1;
   }
+  checkIfExcluded(documentUri) {
+    let docUriAsString = documentUri.toString();
+    const project = this.findProjectForDocument(docUriAsString);
+    return project.exclude ? project.exclude(withoutProtocol(docUriAsString)) : false;
+  }
+  isConfigFile(entry) {
+    const filename = parseFilename(entry.uri.toString(), { strict: false })?.toLowerCase();
+    return !!filename && ProjectsManager.ConfigFileNames.includes(filename);
+  }
   /**
    * Checks if the provided file system entry is a valid project config file.
    *
@@ -87,17 +119,12 @@ export class ProjectsManager {
    */
   async loadConfigFile(entry) {
     if (entry.isDirectory) {
-      return false;
-    }
-    const filename = parseFilename(entry.uri.fsPath, { strict: false });
-    if (!filename) {
-      return false;
+      return void 0;
     }
-    if (ProjectsManager.ConfigFileNames.includes(filename)) {
-      await this.registerProject(entry.uri);
-      return true;
+    if (this.isConfigFile(entry)) {
+      return await this.registerProject(entry.uri);
     }
-    return false;
+    return void 0;
   }
   async registerProject(opts) {
     if (URI.isUri(opts)) {
@@ -109,9 +136,10 @@ export class ProjectsManager {
       return this.registerProject({ config: config2, folderUri: folderUri2 });
     }
     const { config, folderUri } = opts;
-    const id = config.name;
-    if (this._projects.some(({ id: existingId }) => existingId === id)) {
-      throw new Error(`Project ID ${id} already registered`);
+    let id = config.name;
+    let i = 1;
+    while (this.projectIdToFolder.has(id)) {
+      id = `${config.name}-${i++}`;
     }
     let folder;
     if (URI.isUri(folderUri)) {
@@ -119,14 +147,25 @@ export class ProjectsManager {
     } else {
       folder = hasProtocol(folderUri) ? folderUri : withProtocol(folderUri, "file://");
     }
+    const project = {
+      id,
+      config,
+      folder
+    };
+    if (isNullish(config.exclude)) {
+      project.exclude = this.defaultGlobalProject.exclude;
+    } else if (hasAtLeast(config.exclude, 1)) {
+      project.exclude = picomatch(config.exclude);
+    }
     this._projects = pipe(
-      [...this._projects, { folder, config, id }],
+      [...this._projects, project],
       sortBy(
         [({ folder: folder2 }) => withoutProtocol(folder2).split("/").length, "desc"]
       )
     );
     this.projectIdToFolder.set(id, folder);
-    logger.debug`registered project ${id} folder: ${folder})`;
+    logger.info`register project ${id} folder: ${folder})`;
+    return project;
   }
   belongsTo(document) {
     let documentUri;
@@ -137,12 +176,17 @@ export class ProjectsManager {
     } else {
       documentUri = document.uri.toString();
     }
-    return this.mappingsToProject.get(documentUri, () => this.getProjectId(documentUri));
+    return this.findProjectForDocument(documentUri).id;
   }
-  getProjectId(documentUri) {
-    const project = this._projects.find(({ folder }) => documentUri.toString().startsWith(folder));
-    return project?.id ?? ProjectsManager.DefaultProjectId;
+  findProjectForDocument(documentUri) {
+    return this.mappingsToProject.get(documentUri, () => {
+      const project = this._projects.find(({ folder }) => documentUri.startsWith(folder));
+      return project ?? this.defaultGlobalProject;
+    });
   }
+  // The mapping between document URIs and their corresponding project ID
+  // Lazy-created due to initialization order of the LanguageServer
+  _mappingsToProject;
   get mappingsToProject() {
     this._mappingsToProject ??= new WorkspaceCache(this.services);
     return this._mappingsToProject;

package/dist/workspace/WorkspaceManager.d.ts

@@ -1,11 +1,11 @@
-import type { LangiumDocument } from 'langium';
+import type { FileSystemNode, LangiumDocument } from 'langium';
 import { DefaultWorkspaceManager } from 'langium';
 import type { WorkspaceFolder } from 'vscode-languageserver';
 import { URI } from 'vscode-uri';
 import type { LikeC4SharedServices } from '../module';
 export declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
+    private services;
     private documentFactory;
-    private projects;
     constructor(services: LikeC4SharedServices);
     /**
      * Load all additional documents that shall be visible in the context of the given workspace
@@ -14,10 +14,9 @@ export declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
      */
     protected loadAdditionalDocuments(folders: WorkspaceFolder[], collector: (document: LangiumDocument) => void): Promise<void>;
     /**
-     * We override the default implementation to process project config files during the traversal.
-     * This is necessary to ensure that the project config files are loaded and processed correctly.
+     * Determine whether the given folder entry shall be included while indexing the workspace.
      */
-    protected traverseFolder(workspaceFolder: WorkspaceFolder, folderPath: URI, fileExtensions: string[], collector: (document: LangiumDocument) => void): Promise<void>;
+    protected includeEntry(_workspaceFolder: WorkspaceFolder, entry: FileSystemNode, fileExtensions: string[]): boolean;
     workspace(): any;
     get workspaceUri(): URI;
     get workspaceURL(): URL;

package/dist/workspace/WorkspaceManager.js

@@ -2,42 +2,75 @@ import { hasAtLeast, invariant } from "@likec4/core";
 import { DefaultWorkspaceManager } from "langium";
 import { URI } from "vscode-uri";
 import * as BuiltIn from "../likec4lib.js";
+import { logError } from "../logger.js";
 export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
-  documentFactory;
-  projects;
   constructor(services) {
     super(services);
+    this.services = services;
     this.documentFactory = services.workspace.LangiumDocumentFactory;
-    this.projects = services.workspace.ProjectsManager;
   }
+  documentFactory;
   /**
    * Load all additional documents that shall be visible in the context of the given workspace
    * folders and add them to the collector. This can be used to include built-in libraries of
    * your language, which can be either loaded from provided files or constructed in memory.
    */
   async loadAdditionalDocuments(folders, collector) {
+    const projects = this.services.workspace.ProjectsManager;
+    for (const folder of folders) {
+      try {
+        const content = await this.fileSystemProvider.readDirectory(URI.parse(folder.uri));
+        for (const entry of content) {
+          try {
+            await projects.loadConfigFile(entry);
+          } catch (error) {
+            logError(error);
+          }
+        }
+      } catch (error) {
+        logError(error);
+      }
+    }
     collector(this.documentFactory.fromString(BuiltIn.Content, URI.parse(BuiltIn.Uri)));
     await super.loadAdditionalDocuments(folders, collector);
   }
+  // /**
+  //  * We override the default implementation to process project config files during the traversal.
+  //  * This is necessary to ensure that the project config files are loaded and processed correctly.
+  //  */
+  // protected override async traverseFolder(
+  //   workspaceFolder: WorkspaceFolder,
+  //   folderPath: URI,
+  //   fileExtensions: string[],
+  //   collector: (document: LangiumDocument) => void,
+  // ): Promise<void> {
+  //   // Then load other files
+  //   for (const entry of nonConfigFiles) {
+  //     try {
+  //       if (this.includeEntry(workspaceFolder, entry, fileExtensions)) {
+  //         if (entry.isDirectory) {
+  //           await this.traverseFolder(workspaceFolder, entry.uri, fileExtensions, collector)
+  //         } else if (entry.isFile) {
+  //           const document = await this.langiumDocuments.getOrCreateDocument(entry.uri)
+  //           collector(document)
+  //         }
+  //       }
+  //     } catch (error) {
+  //       logError(error)
+  //     }
+  //   }
+  // }
   /**
-   * We override the default implementation to process project config files during the traversal.
-   * This is necessary to ensure that the project config files are loaded and processed correctly.
+   * Determine whether the given folder entry shall be included while indexing the workspace.
    */
-  async traverseFolder(workspaceFolder, folderPath, fileExtensions, collector) {
-    const content = await this.fileSystemProvider.readDirectory(folderPath);
-    await Promise.all(content.map(async (entry) => {
-      if (await this.projects.loadConfigFile(entry)) {
-        return;
-      }
-      if (this.includeEntry(workspaceFolder, entry, fileExtensions)) {
-        if (entry.isDirectory) {
-          await this.traverseFolder(workspaceFolder, entry.uri, fileExtensions, collector);
-        } else if (entry.isFile) {
-          const document = await this.langiumDocuments.getOrCreateDocument(entry.uri);
-          collector(document);
-        }
-      }
-    }));
+  includeEntry(_workspaceFolder, entry, fileExtensions) {
+    if (this.services.workspace.ProjectsManager.isConfigFile(entry)) {
+      return false;
+    }
+    if (entry.isFile) {
+      return !this.services.workspace.ProjectsManager.checkIfExcluded(entry.uri);
+    }
+    return super.includeEntry(_workspaceFolder, entry, fileExtensions);
   }
   workspace() {
     if (this.folders && hasAtLeast(this.folders, 1)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "1.27.2",
+  "version": "1.28.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -109,24 +109,26 @@
     "p-debounce": "^4.0.0",
     "pretty-ms": "^9.2.0",
     "remeda": "^2.21.2",
+    "@types/picomatch": "^4.0.0",
+    "picomatch": "^4.0.2",
     "strip-indent": "^4.0.0",
     "tsx": "~4.19.3",
-    "turbo": "^2.4.4",
-    "type-fest": "^4.38.0",
-    "typescript": "^5.8.2",
+    "turbo": "^2.5.0",
+    "type-fest": "^4.39.1",
+    "typescript": "^5.8.3",
     "ufo": "^1.5.4",
     "unbuild": "^3.5.0",
     "valibot": "^1.0.0",
-    "vitest": "^3.0.9",
+    "vitest": "^3.1.1",
     "vscode-languageserver": "9.0.1",
     "vscode-languageserver-types": "3.17.5",
     "vscode-languageserver-protocol": "3.17.5",
     "which": "^5.0.0",
-    "@likec4/core": "1.27.2",
-    "@likec4/icons": "1.27.2",
-    "@likec4/layouts": "1.27.2",
-    "@likec4/log": "1.27.2",
-    "@likec4/tsconfig": "1.27.2"
+    "@likec4/core": "1.28.0",
+    "@likec4/icons": "1.28.0",
+    "@likec4/log": "1.28.0",
+    "@likec4/layouts": "1.28.0",
+    "@likec4/tsconfig": "1.28.0"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",

package/dist/validation/dynamic-view-rule.d.ts

@@ -1,4 +0,0 @@
-import type { ValidationCheck } from 'langium';
-import { ast } from '../ast';
-import type { LikeC4Services } from '../module';
-export declare const dynamicViewRulePredicate: (_services: LikeC4Services) => ValidationCheck<ast.DynamicViewPredicateIterator>;

package/dist/validation/dynamic-view-rule.js

@@ -1,17 +0,0 @@
-import { ast, elementExpressionFromPredicate } from "../ast.js";
-import { tryOrLog } from "./_shared.js";
-export const dynamicViewRulePredicate = (_services) => {
-  return tryOrLog((predicate, accept) => {
-    const expr = elementExpressionFromPredicate(predicate.value);
-    switch (true) {
-      case ast.isElementKindExpression(expr):
-      case ast.isElementTagExpression(expr):
-      case ast.isWildcardExpression(expr): {
-        accept("warning", `Predicate is ignored, as not supported in dynamic views`, {
-          node: predicate
-        });
-        return;
-      }
-    }
-  });
-};

package/dist/validation/view-predicates/element-with.js

@@ -1,31 +0,0 @@
-import { nonexhaustive } from "@likec4/core";
-import { AstUtils } from "langium";
-import { ast } from "../../ast.js";
-import { tryOrLog } from "../_shared.js";
-export const elementPredicateWithChecks = (_services) => {
-  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/dist/validation/view-predicates/expanded-element.js

@@ -1,12 +0,0 @@
-import { AstUtils } from "langium";
-import { ast } from "../../ast.js";
-import { tryOrLog } from "../_shared.js";
-export const expandElementExprChecks = (_services) => {
-  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/dist/validation/view-predicates/expression-v2.d.ts

@@ -1,5 +0,0 @@
-import { type ValidationCheck } from 'langium';
-import { ast } from '../../ast';
-import type { LikeC4Services } from '../../module';
-export declare const relationExprChecks: (services: LikeC4Services) => ValidationCheck<ast.RelationExpr>;
-export declare const fqnRefExprChecks: (services: LikeC4Services) => ValidationCheck<ast.FqnRefExpr>;

package/dist/validation/view-predicates/expression-v2.js

@@ -1,83 +0,0 @@
-import { FqnExpr, FqnRef } from "@likec4/core";
-import { AstUtils } from "langium";
-import { isNonNullish, isNullish } from "remeda";
-import { ast } from "../../ast.js";
-import { tryOrLog } from "../_shared.js";
-export const relationExprChecks = (services) => {
-  const ModelParser = services.likec4.ModelParser;
-  return tryOrLog((node, accept) => {
-    if (node.$container.$type !== "DeploymentViewRulePredicateExpression") {
-      return;
-    }
-    const predicate = AstUtils.getContainerOfType(node, ast.isDeploymentViewRulePredicate);
-    if (!predicate || predicate.isInclude !== true) {
-      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;
-    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) => {
-  const ModelParser = services.likec4.ModelParser;
-  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);
-    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"
-      });
-    }
-  });
-};