@likec4/language-server 0.46.1 → 0.47.0

package/dist/lsp/SemanticTokenProvider.js

@@ -11,13 +11,6 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         modifier: [SemanticTokenModifiers.definition]
       });
     }
-    if (ast.isElementRef(node) || ast.isFqnElementRef(node)) {
-      acceptor({
-        node,
-        property: "el",
-        type: node.parent ? SemanticTokenTypes.property : SemanticTokenTypes.variable
-      });
-    }
     if (ast.isElementViewRef(node)) {
       acceptor({
         node,
@@ -25,21 +18,19 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         type: SemanticTokenTypes.variable
       });
     }
-    if (ast.isElementRefExpression(node) && node.isDescedants) {
+    if (ast.isDescedantsExpr(node) && node.$cstNode) {
       acceptor({
-        node,
-        keyword: ".*",
+        cst: node.$cstNode,
         type: SemanticTokenTypes.variable
       });
     }
-    if (ast.isWildcardExpression(node)) {
+    if (ast.isWildcardExpr(node) && node.$cstNode) {
       acceptor({
-        node,
-        property: "isWildcard",
+        cst: node.$cstNode,
         type: SemanticTokenTypes.variable
       });
     }
-    if (ast.isElementKindExpression(node)) {
+    if (ast.isElementKindExpr(node)) {
       acceptor({
         node,
         property: "kind",
@@ -47,7 +38,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         modifier: [SemanticTokenModifiers.definition]
       });
     }
-    if (ast.isElementTagExpression(node)) {
+    if (ast.isElementTagExpr(node)) {
       acceptor({
         node,
         property: "tag",
@@ -55,7 +46,14 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         modifier: [SemanticTokenModifiers.definition]
       });
     }
-    if (ast.isSpecificationElementKind(node)) {
+    if (ast.isElementRef(node) || ast.isFqnElementRef(node)) {
+      acceptor({
+        node,
+        property: "el",
+        type: node.parent ? SemanticTokenTypes.property : SemanticTokenTypes.variable
+      });
+    }
+    if (ast.isSpecificationElementKind(node) || ast.isSpecificationRelationshipKind(node)) {
       acceptor({
         node,
         property: "kind",
@@ -79,14 +77,6 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         modifier: [SemanticTokenModifiers.definition]
       });
     }
-    if (ast.isSpecificationRelationshipKind(node)) {
-      acceptor({
-        node,
-        property: "kind",
-        type: SemanticTokenTypes.type,
-        modifier: [SemanticTokenModifiers.definition]
-      });
-    }
     if (ast.isColorProperty(node) || ast.isShapeProperty(node) || ast.isArrowProperty(node) || ast.isLineProperty(node)) {
       acceptor({
         node,
@@ -104,7 +94,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
     if (ast.isElement(node)) {
       this.highlightAstElement(node, acceptor);
     }
-    if (ast.isView(node)) {
+    if (ast.isElementView(node)) {
       this.highlightView(node, acceptor);
     }
   }

package/dist/model/fqn-index.d.ts

@@ -1,12 +1,7 @@
 import type { Fqn } from '@likec4/core';
-import type { LangiumDocument, LangiumDocuments, Stream } from 'langium';
-import type { ast } from '../ast';
-import { type LikeC4LangiumDocument } from '../ast';
+import type { LangiumDocuments, Stream } from 'langium';
+import type { FqnIndexedDocument, ast } from '../ast';
 import type { LikeC4Services } from '../module';
-export type FqnIndexedDocument = Omit<LikeC4LangiumDocument, 'c4fqns'> & {
-    c4fqns: NonNullable<LikeC4LangiumDocument['c4fqns']>;
-};
-export declare function isFqnIndexedDocument(doc: LangiumDocument): doc is FqnIndexedDocument;
 export interface FqnIndexEntry {
     fqn: Fqn;
     name: string;

package/dist/model/fqn-index.js

@@ -1,13 +1,10 @@
 import { nameFromFqn, parentFqn } from "@likec4/core";
-import { DONE_RESULT, DocumentState, MultiMap, StreamImpl, getDocument, stream } from "langium";
-import { isNil } from "remeda";
-import { ElementOps, isLikeC4LangiumDocument } from "../ast.js";
+import { DONE_RESULT, DocumentState, MultiMap, StreamImpl, stream } from "langium";
+import { ElementOps, isFqnIndexedDocument, isLikeC4LangiumDocument } from "../ast.js";
 import { logError, logger } from "../logger.js";
 import { printDocs } from "../utils.js";
 import { computeDocumentFqn } from "./fqn-computation.js";
-export function isFqnIndexedDocument(doc) {
-  return isLikeC4LangiumDocument(doc) && doc.state >= DocumentState.IndexedContent && !isNil(doc.c4fqns);
-}
+const True = () => true;
 export class FqnIndex {
   constructor(services) {
     this.services = services;
@@ -40,37 +37,28 @@ export class FqnIndex {
   get documents() {
     return this.langiumDocuments.all.filter(isFqnIndexedDocument);
   }
-  entries(filterByFqn = () => true) {
+  entries(filterByFqn = True) {
     return this.documents.flatMap(
-      (doc) => doc.c4fqns.entries().filter(([fqn]) => filterByFqn(fqn)).map(([fqn, entry]) => {
-        const el = entry.el.deref();
-        if (el) {
-          return { ...entry, fqn, el, doc };
+      (doc) => doc.c4fqns.entries().flatMap(([fqn, entry]) => {
+        if (filterByFqn(fqn)) {
+          const el = entry.el.deref();
+          if (el) {
+            return { ...entry, fqn, el, doc };
+          }
         }
-        return null;
-      }).nonNullable()
+        return [];
+      })
     );
   }
   getFqn(el) {
-    let fqn = ElementOps.readId(el) ?? null;
-    if (fqn) {
-      const doc = getDocument(el);
-      if (isFqnIndexedDocument(doc) && doc.c4fqns.has(fqn)) {
-        return fqn;
-      }
-      const path = this.services.workspace.AstNodeLocator.getAstNodePath(el);
-      logError(`Clean cached FQN ${fqn} at ${path}`);
-      ElementOps.writeId(el, null);
-      fqn = null;
-    }
-    return fqn;
+    return ElementOps.readId(el) ?? null;
   }
   byFqn(fqn) {
     return this.documents.flatMap((doc) => {
       return doc.c4fqns.get(fqn).flatMap((entry) => {
         const el = entry.el.deref();
         if (el) {
-          return [{ fqn, el, doc, path: entry.path, name: entry.name }];
+          return { fqn, el, doc, path: entry.path, name: entry.name };
         }
         return [];
       });

package/dist/model/model-builder.js

@@ -240,9 +240,11 @@ ${printDocs(docs)}`);
     );
     const computedView = result.view;
     computedView.nodes.forEach((node) => {
-      const navigateTo = R.find(allElementViews, (v) => v.viewOf === node.id);
-      if (navigateTo) {
-        node.navigateTo = navigateTo.id;
+      if (!node.navigateTo) {
+        const navigateTo = R.find(allElementViews, (v) => v.viewOf === node.id);
+        if (navigateTo) {
+          node.navigateTo = navigateTo.id;
+        }
       }
     });
     return computedView;

package/dist/model/model-parser.d.ts

@@ -15,8 +15,9 @@ export declare class LikeC4ModelParser {
     private parseElement;
     private parseRelation;
     private parseViews;
-    private parseElementExpression;
-    private parseExpression;
+    private parseElementExpr;
+    private parseCustomElementExpr;
+    private parsePredicateExpr;
     private parseViewRule;
     private parseElementView;
     protected resolveFqn(node: ast.Element | ast.ExtendElement): c4.Fqn;

package/dist/model/model-parser.js

@@ -1,4 +1,9 @@
-import { InvalidModelError, invariant, isNonEmptyArray, nonexhaustive } from "@likec4/core";
+import {
+  InvalidModelError,
+  invariant,
+  isNonEmptyArray,
+  nonexhaustive
+} from "@likec4/core";
 import { getDocument } from "langium";
 import objectHash from "object-hash";
 import stripIndent from "strip-indent";
@@ -6,6 +11,7 @@ import {
   ElementViewOps,
   ast,
   cleanParsedModel,
+  isFqnIndexedDocument,
   isLikeC4LangiumDocument,
   resolveRelationPoints,
   streamModel,
@@ -16,6 +22,13 @@ import {
 } from "../ast.js";
 import { elementRef, getFqnElementRef } from "../elementRef.js";
 import { logError, logWarnError, logger } from "../logger.js";
+import { isTruthy } from "remeda";
+function toSingleLine(str) {
+  return str?.split("\n").join(" ").trim();
+}
+function removeIndent(str) {
+  return str ? stripIndent(str).trim() : void 0;
+}
 export class LikeC4ModelParser {
   constructor(services) {
     this.services = services;
@@ -39,6 +52,7 @@ export class LikeC4ModelParser {
     return result;
   }
   parseLikeC4Document(_doc) {
+    invariant(isFqnIndexedDocument(_doc), "Not a FqnIndexedDocument");
     const doc = cleanParsedModel(_doc);
     this.parseSpecification(doc);
     this.parseModel(doc);
@@ -100,29 +114,26 @@ export class LikeC4ModelParser {
   }
   parseElement(astNode) {
     const id = this.resolveFqn(astNode);
-    invariant(astNode.kind.ref, "Element kind is not resolved: " + astNode.name);
-    const kind = astNode.kind.ref.name;
+    const kind = astNode.kind.$refText;
     const tags = this.convertTags(astNode.body);
     const stylePropsAst = astNode.body?.props.find(ast.isStyleProperties)?.props;
     const styleProps = toElementStyleExcludeDefaults(stylePropsAst);
     const astPath = this.getAstNodePath(astNode);
     let [title, description, technology] = astNode.props;
-    const bodyProps = astNode.body?.props.filter(
-      (p) => ast.isElementStringProperty(p)
-    ) ?? [];
-    title = title ?? bodyProps.find((p) => p.key === "title")?.value;
-    description = description ?? bodyProps.find((p) => p.key === "description")?.value;
-    technology = technology ?? bodyProps.find((p) => p.key === "technology")?.value;
+    const bodyProps = astNode.body?.props.filter(ast.isElementStringProperty) ?? [];
+    title = toSingleLine(title ?? bodyProps.find((p) => p.key === "title")?.value);
+    description = removeIndent(description ?? bodyProps.find((p) => p.key === "description")?.value);
+    technology = toSingleLine(technology ?? bodyProps.find((p) => p.key === "technology")?.value);
     const links = astNode.body?.props.filter(ast.isLinkProperty).map((p) => p.value);
     return {
       id,
       kind,
       astPath,
-      title: title ? stripIndent(title).trim() : astNode.name,
+      title: title ?? astNode.name,
       ...tags && { tags },
       ...links && isNonEmptyArray(links) && { links },
-      ...technology && { technology },
-      ...description && { description: stripIndent(description).trim() },
+      ...isTruthy(technology) && { technology },
+      ...isTruthy(description) && { description },
       ...styleProps
     };
   }
@@ -133,7 +144,7 @@ export class LikeC4ModelParser {
     const tags = this.convertTags(astNode);
     const kind = astNode.kind?.ref?.name;
     const astPath = this.getAstNodePath(astNode);
-    const title = astNode.title ?? astNode.props.find((p) => p.key === "title")?.value ?? "";
+    const title = toSingleLine(astNode.title ?? astNode.props.find((p) => p.key === "title")?.value) ?? "";
     const id = objectHash({
       astPath,
       source,
@@ -160,81 +171,130 @@ export class LikeC4ModelParser {
       }
     }
   }
-  parseElementExpression(astNode) {
-    if (ast.isWildcardExpression(astNode)) {
+  parseElementExpr(astNode) {
+    if (ast.isWildcardExpr(astNode)) {
       return {
         wildcard: true
       };
     }
-    if (ast.isElementKindExpression(astNode)) {
-      invariant(
-        astNode.kind.ref,
-        "ElementKindExpression kind is not resolved: " + astNode.$cstNode?.text
-      );
+    if (ast.isElementKindExpr(astNode)) {
       return {
-        elementKind: astNode.kind.ref.name,
+        elementKind: astNode.kind.$refText,
         isEqual: astNode.isEqual
       };
     }
-    if (ast.isElementTagExpression(astNode)) {
-      invariant(
-        astNode.tag.ref,
-        "ElementTagExpression tag is not resolved: " + astNode.$cstNode?.text
-      );
+    if (ast.isElementTagExpr(astNode)) {
+      let elementTag = astNode.tag.$refText;
+      if (elementTag.startsWith("#")) {
+        elementTag = elementTag.slice(1);
+      }
       return {
-        elementTag: astNode.tag.ref.name,
+        elementTag,
         isEqual: astNode.isEqual
       };
     }
-    if (ast.isElementRefExpression(astNode)) {
-      const elementNode = elementRef(astNode.id);
-      invariant(elementNode, "Element not found " + astNode.id.$cstNode?.text);
+    if (ast.isDescedantsExpr(astNode)) {
+      const elementNode = elementRef(astNode.parent);
+      invariant(elementNode, "Element not found " + astNode.parent.$cstNode?.text);
       const element = this.resolveFqn(elementNode);
-      return astNode.isDescedants ? {
+      return {
         element,
-        isDescedants: astNode.isDescedants
-      } : {
+        isDescedants: true
+      };
+    }
+    if (ast.isElementRef(astNode)) {
+      const elementNode = elementRef(astNode);
+      invariant(elementNode, "Element not found " + astNode.$cstNode?.text);
+      const element = this.resolveFqn(elementNode);
+      return {
         element
       };
     }
     nonexhaustive(astNode);
   }
-  parseExpression(astNode) {
-    if (ast.isElementExpression(astNode)) {
-      return this.parseElementExpression(astNode);
-    }
-    if (ast.isIncomingExpression(astNode)) {
+  parseCustomElementExpr(astNode) {
+    invariant(ast.isElementRef(astNode.target), "ElementRef expected as target of custom element");
+    const elementNode = elementRef(astNode.target);
+    invariant(elementNode, "element not found: " + astNode.$cstNode?.text);
+    const element = this.resolveFqn(elementNode);
+    const props = astNode.body?.props ?? [];
+    return props.reduce(
+      (acc, prop) => {
+        if (ast.isNavigateToProperty(prop)) {
+          const viewId = prop.value.view.$refText;
+          if (isTruthy(viewId)) {
+            acc.custom.navigateTo = viewId;
+          }
+          return acc;
+        }
+        if (ast.isElementStringProperty(prop)) {
+          const value = prop.key === "description" ? removeIndent(prop.value) : toSingleLine(prop.value);
+          acc.custom[prop.key] = value.trim();
+          return acc;
+        }
+        if (ast.isColorProperty(prop)) {
+          acc.custom[prop.key] = prop.value;
+          return acc;
+        }
+        if (ast.isShapeProperty(prop)) {
+          acc.custom[prop.key] = prop.value;
+          return acc;
+        }
+        nonexhaustive(prop);
+      },
+      {
+        custom: {
+          element
+        }
+      }
+    );
+  }
+  parsePredicateExpr(astNode) {
+    if (ast.isRelationExpr(astNode)) {
       return {
-        incoming: this.parseElementExpression(astNode.target)
+        source: this.parseElementExpr(astNode.source),
+        target: this.parseElementExpr(astNode.target)
       };
     }
-    if (ast.isOutgoingExpression(astNode)) {
+    if (ast.isInOutExpr(astNode)) {
       return {
-        outgoing: this.parseElementExpression(astNode.source)
+        inout: this.parseElementExpr(astNode.inout.to)
       };
     }
-    if (ast.isInOutExpression(astNode)) {
+    if (ast.isOutgoingExpr(astNode)) {
       return {
-        inout: this.parseElementExpression(astNode.inout.target)
+        outgoing: this.parseElementExpr(astNode.from)
       };
     }
-    if (ast.isRelationExpression(astNode)) {
+    if (ast.isIncomingExpr(astNode)) {
       return {
-        source: this.parseElementExpression(astNode.source),
-        target: this.parseElementExpression(astNode.target)
+        incoming: this.parseElementExpr(astNode.to)
       };
     }
+    if (ast.isCustomElementExpr(astNode)) {
+      return this.parseCustomElementExpr(astNode);
+    }
+    if (ast.isElementExpr(astNode)) {
+      return this.parseElementExpr(astNode);
+    }
     nonexhaustive(astNode);
   }
   parseViewRule(astRule) {
-    if (ast.isViewRuleExpression(astRule)) {
-      const exprs = astRule.expressions.map((n) => this.parseExpression(n));
-      return astRule.isInclude ? { include: exprs } : { exclude: exprs };
+    if (ast.isIncludePredicate(astRule) || ast.isExcludePredicate(astRule)) {
+      const exprs = astRule.expressions.flatMap((n) => {
+        try {
+          return this.parsePredicateExpr(n);
+        } catch (e) {
+          logWarnError(e);
+          return [];
+        }
+      });
+      return ast.isIncludePredicate(astRule) ? { include: exprs } : { exclude: exprs };
     }
     if (ast.isViewRuleStyle(astRule)) {
-      const styleProps = toElementStyle(astRule.props);
+      const styleProps = toElementStyle(astRule.styleprops);
       return {
-        targets: astRule.targets.map((n) => this.parseElementExpression(n)),
+        targets: astRule.targets.map((n) => this.parseElementExpr(n)),
         style: {
           ...styleProps
         }

package/dist/module.js

@@ -16,7 +16,7 @@ import { Rpc } from "./Rpc.js";
 import { registerValidationChecks } from "./validation/index.js";
 import { logger } from "./logger.js";
 import { serializeError } from "@likec4/core";
-import { NodeKindProvider } from "./shared/NodeKindProvider.js";
+import { WorkspaceSymbolProvider, NodeKindProvider } from "./shared/index.js";
 function bind(Type) {
   return (services) => new Type(services);
 }
@@ -43,7 +43,8 @@ export const LikeC4Module = {
 };
 const LikeC4SharedModule = {
   lsp: {
-    NodeKindProvider: () => new NodeKindProvider()
+    NodeKindProvider: (services) => new NodeKindProvider(services),
+    WorkspaceSymbolProvider: (services) => new WorkspaceSymbolProvider(services)
   }
   // workspace: {
   //   WorkspaceManager: services => new LikeC4WorkspaceManager(services)

package/dist/references/scope-computation.js

@@ -2,54 +2,72 @@ import {
   DefaultScopeComputation,
   MultiMap
 } from "langium";
-import { hasAtLeast, isEmpty } from "remeda";
+import { isEmpty, isTruthy } from "remeda";
 import { ast } from "../ast.js";
 import { logError } from "../logger.js";
 export class LikeC4ScopeComputation extends DefaultScopeComputation {
   computeExports(document, _cancelToken) {
+    const docExports = [];
+    const { specifications, models, views } = document.parseResult.value;
     try {
-      const { specifications, models, views } = document.parseResult.value;
-      const docExports = [];
       for (const spec of specifications.flatMap((s) => s.elements)) {
-        if (spec.kind && !isEmpty(spec.kind.name)) {
+        if (spec.kind && isTruthy(spec.kind.name)) {
           docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
         }
       }
+    } catch (e) {
+      logError(e);
+    }
+    try {
       for (const spec of specifications.flatMap((s) => s.tags)) {
-        if (spec.tag && !isEmpty(spec.tag.name)) {
-          docExports.push(this.descriptions.createDescription(spec.tag, spec.tag.name, document));
+        if (spec.tag && isTruthy(spec.tag.name)) {
           docExports.push(
             this.descriptions.createDescription(spec.tag, "#" + spec.tag.name, document)
           );
         }
       }
+    } catch (e) {
+      logError(e);
+    }
+    try {
       for (const spec of specifications.flatMap((s) => s.relationships)) {
-        if (spec.kind && !isEmpty(spec.kind.name)) {
+        if (spec.kind && isTruthy(spec.kind.name)) {
           docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
         }
       }
+    } catch (e) {
+      logError(e);
+    }
+    try {
       for (const elAst of models.flatMap((m) => m.elements)) {
         if (ast.isElement(elAst) && !isEmpty(elAst.name)) {
           docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
         }
       }
+    } catch (e) {
+      logError(e);
+    }
+    try {
       for (const viewAst of views.flatMap((v) => v.views)) {
-        if (viewAst.name && !isEmpty(viewAst.name)) {
+        if (isTruthy(viewAst.name)) {
           docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document));
         }
       }
-      return Promise.resolve(docExports);
     } catch (e) {
       logError(e);
-      return Promise.reject(e);
     }
+    return Promise.resolve(docExports);
   }
   async computeLocalScopes(document, _cancelToken) {
     const root = document.parseResult.value;
     const scopes = new MultiMap();
-    if (hasAtLeast(root.models, 1)) {
-      const nested = this.processContainer(root.models[0], scopes, document);
-      scopes.addAll(root, nested.values());
+    for (const model of root.models) {
+      try {
+        const nested = this.processContainer(model, scopes, document);
+        scopes.addAll(root, nested.values());
+      } catch (e) {
+        logError(e);
+      }
     }
     return Promise.resolve(scopes);
   }
@@ -61,8 +79,10 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
         continue;
       }
       let subcontainer;
-      if (ast.isElement(el) && !isEmpty(el.name)) {
-        localScope.add(el.name, this.descriptions.createDescription(el, el.name, document));
+      if (ast.isElement(el)) {
+        if (isTruthy(el.name)) {
+          localScope.add(el.name, this.descriptions.createDescription(el, el.name, document));
+        }
         subcontainer = el.body;
       } else if (ast.isExtendElement(el)) {
         subcontainer = el.body;

package/dist/references/scope-provider.d.ts

@@ -1,4 +1,3 @@
-import type { AstNode } from 'langium';
 import { DefaultScopeProvider, type ReferenceInfo, type Scope } from 'langium';
 import type { LikeC4Services } from '../module';
 export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
@@ -10,7 +9,7 @@ export declare class LikeC4ScopeProvider extends DefaultScopeProvider {
     private scopeExtendElement;
     private scopeElementView;
     getScope(context: ReferenceInfo): Scope;
-    protected computeScope(node: AstNode, referenceType: string): Scope;
+    protected computeScope(context: ReferenceInfo): Scope;
     /**
      * Create a global scope filtered for the given reference type.
      */

package/dist/references/scope-provider.js

@@ -58,15 +58,12 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
   scopeElementRef(ref) {
     return this.uniqueDescedants(() => ref.el.ref);
   }
-  scopeExtendElement(extend) {
-    return this.uniqueDescedants(() => elementRef(extend.element));
+  scopeExtendElement({ element }) {
+    return stream([element.el.$nodeDescription]).nonNullable().concat(this.uniqueDescedants(() => elementRef(element)));
   }
   scopeElementView({ viewOf, extends: ext }) {
     if (viewOf) {
-      return stream([viewOf]).flatMap((v) => {
-        const el = elementRef(v);
-        return el ? this.descriptions.createDescription(el, el.name) : [];
-      }).concat(this.uniqueDescedants(() => elementRef(viewOf)));
+      return stream([viewOf.el.$nodeDescription]).nonNullable().concat(this.uniqueDescedants(() => elementRef(viewOf)));
     }
     if (ext) {
       return stream([ext]).flatMap((v) => {
@@ -93,38 +90,33 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
           return new StreamScope(this.scopeElementRef(parent));
         }
       }
-      return this.computeScope(container, referenceType);
+      return this.computeScope(context);
     } catch (e) {
       logError(e);
       return this.getGlobalScope(referenceType);
     }
   }
-  computeScope(node, referenceType) {
+  computeScope(context) {
+    const referenceType = this.reflection.getReferenceType(context);
     const scopes = [];
-    const doc = getDocument(node);
+    const doc = getDocument(context.container);
     const precomputed = doc.precomputedScopes;
     const byReferenceType = (desc) => this.reflection.isSubtype(desc.type, referenceType);
-    if (precomputed) {
-      const elements = precomputed.get(node).filter(byReferenceType);
-      if (elements.length > 0) {
+    let container = context.container;
+    while (container) {
+      const elements = precomputed?.get(container).filter(byReferenceType);
+      if (elements && elements.length > 0) {
         scopes.push(stream(elements));
       }
-      let container = node.$container;
-      while (container) {
-        const elements2 = precomputed.get(container).filter(byReferenceType);
-        if (elements2.length > 0) {
-          scopes.push(stream(elements2));
+      if (referenceType === ast.Element) {
+        if (ast.isExtendElementBody(container)) {
+          scopes.push(this.scopeExtendElement(container.$container));
         }
-        if (referenceType === ast.Element) {
-          if (ast.isExtendElementBody(container)) {
-            scopes.push(this.scopeExtendElement(container.$container));
-          }
-          if (ast.isElementViewBody(container)) {
-            scopes.push(this.scopeElementView(container.$container));
-          }
+        if (ast.isElementViewBody(container)) {
+          scopes.push(this.scopeElementView(container.$container));
         }
-        container = container.$container;
       }
+      container = container.$container;
     }
     return scopes.reduceRight((outerScope, elements) => {
       return this.createScope(elements, outerScope);