zenstack 1.0.0-alpha.23 → 1.0.0-alpha.25

package/language-server/zmodel-linker.js

@@ -1,364 +1,361 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZModelLinker = void 0;
-var _ast = require("@zenstackhq/language/ast");
-var _langium = require("langium");
-var _vscodeJsonrpc = require("vscode-jsonrpc");
-var _utils = require("./utils");
-var _utils2 = require("./validator/utils");
+const ast_1 = require("@zenstackhq/language/ast");
+const langium_1 = require("langium");
+const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+const utils_1 = require("./utils");
+const utils_2 = require("./validator/utils");
 /**
  * Langium linker implementation which links references and resolves expression types
  */
-class ZModelLinker extends _langium.DefaultLinker {
-  constructor(services) {
-    super(services);
-    this.descriptions = services.workspace.AstNodeDescriptionProvider;
-  }
-
-  //#region Reference linking
-
-  async link(document, cancelToken = _vscodeJsonrpc.CancellationToken.None) {
-    var _document$parseResult, _document$parseResult2;
-    if (((_document$parseResult = document.parseResult.lexerErrors) === null || _document$parseResult === void 0 ? void 0 : _document$parseResult.length) > 0 || ((_document$parseResult2 = document.parseResult.parserErrors) === null || _document$parseResult2 === void 0 ? void 0 : _document$parseResult2.length) > 0) {
-      return;
+class ZModelLinker extends langium_1.DefaultLinker {
+    constructor(services) {
+        super(services);
+        this.descriptions = services.workspace.AstNodeDescriptionProvider;
     }
-    for (const node of (0, _langium.streamContents)(document.parseResult.value)) {
-      await (0, _langium.interruptAndCheck)(cancelToken);
-      this.resolve(node, document);
+    //#region Reference linking
+    link(document, cancelToken = vscode_jsonrpc_1.CancellationToken.None) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (((_a = document.parseResult.lexerErrors) === null || _a === void 0 ? void 0 : _a.length) > 0 || ((_b = document.parseResult.parserErrors) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+                return;
+            }
+            for (const node of (0, langium_1.streamContents)(document.parseResult.value)) {
+                yield (0, langium_1.interruptAndCheck)(cancelToken);
+                this.resolve(node, document);
+            }
+            document.state = langium_1.DocumentState.Linked;
+        });
     }
-    document.state = _langium.DocumentState.Linked;
-  }
-  linkReference(container, property, document, extraScopes) {
-    if (!this.resolveFromScopeProviders(container, property, document, extraScopes)) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const reference = container[property];
-      this.doLink({
-        reference,
-        container,
-        property
-      }, document);
+    linkReference(container, property, document, extraScopes) {
+        if (!this.resolveFromScopeProviders(container, property, document, extraScopes)) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const reference = container[property];
+            this.doLink({ reference, container, property }, document);
+        }
     }
-  }
-
-  //#endregion
-
-  //#region Expression type resolving
-
-  resolveFromScopeProviders(node, property, document, providers) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const reference = node[property];
-    for (const provider of providers) {
-      const target = provider(reference.$refText);
-      if (target) {
-        reference._ref = target;
-        reference._nodeDescription = this.descriptions.createDescription(target, target.name, document);
-        return target;
-      }
+    //#endregion
+    //#region Expression type resolving
+    resolveFromScopeProviders(node, property, document, providers) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const reference = node[property];
+        for (const provider of providers) {
+            const target = provider(reference.$refText);
+            if (target) {
+                reference._ref = target;
+                reference._nodeDescription = this.descriptions.createDescription(target, target.name, document);
+                return target;
+            }
+        }
+        return null;
     }
-    return null;
-  }
-  resolve(node, document, extraScopes = []) {
-    switch (node.$type) {
-      case _ast.LiteralExpr:
-        this.resolveLiteral(node);
-        break;
-      case _ast.InvocationExpr:
-        this.resolveInvocation(node, document, extraScopes);
-        break;
-      case _ast.ArrayExpr:
-        this.resolveArray(node, document, extraScopes);
-        break;
-      case _ast.ReferenceExpr:
-        this.resolveReference(node, document, extraScopes);
-        break;
-      case _ast.MemberAccessExpr:
-        this.resolveMemberAccess(node, document, extraScopes);
-        break;
-      case _ast.UnaryExpr:
-        this.resolveUnary(node, document, extraScopes);
-        break;
-      case _ast.BinaryExpr:
-        this.resolveBinary(node, document, extraScopes);
-        break;
-      case _ast.ThisExpr:
-        this.resolveThis(node, document, extraScopes);
-        break;
-      case _ast.NullExpr:
-        this.resolveNull(node, document, extraScopes);
-        break;
-      case _ast.AttributeArg:
-        this.resolveAttributeArg(node, document, extraScopes);
-        break;
-      default:
-        this.resolveDefault(node, document, extraScopes);
-        break;
+    resolve(node, document, extraScopes = []) {
+        switch (node.$type) {
+            case ast_1.LiteralExpr:
+                this.resolveLiteral(node);
+                break;
+            case ast_1.InvocationExpr:
+                this.resolveInvocation(node, document, extraScopes);
+                break;
+            case ast_1.ArrayExpr:
+                this.resolveArray(node, document, extraScopes);
+                break;
+            case ast_1.ReferenceExpr:
+                this.resolveReference(node, document, extraScopes);
+                break;
+            case ast_1.MemberAccessExpr:
+                this.resolveMemberAccess(node, document, extraScopes);
+                break;
+            case ast_1.UnaryExpr:
+                this.resolveUnary(node, document, extraScopes);
+                break;
+            case ast_1.BinaryExpr:
+                this.resolveBinary(node, document, extraScopes);
+                break;
+            case ast_1.ThisExpr:
+                this.resolveThis(node, document, extraScopes);
+                break;
+            case ast_1.NullExpr:
+                this.resolveNull(node, document, extraScopes);
+                break;
+            case ast_1.AttributeArg:
+                this.resolveAttributeArg(node, document, extraScopes);
+                break;
+            default:
+                this.resolveDefault(node, document, extraScopes);
+                break;
+        }
     }
-  }
-  resolveBinary(node, document, extraScopes) {
-    switch (node.operator) {
-      // TODO: support arithmetics?
-      // case '+':
-      // case '-':
-      // case '*':
-      // case '/':
-      //     this.resolve(node.left, document, extraScopes);
-      //     this.resolve(node.right, document, extraScopes);
-      //     this.resolveToBuiltinTypeOrDecl(node, 'Int');
-      //     break;
-
-      case '>':
-      case '>=':
-      case '<':
-      case '<=':
-      case '==':
-      case '!=':
-      case '&&':
-      case '||':
-        this.resolve(node.left, document, extraScopes);
-        this.resolve(node.right, document, extraScopes);
-        this.resolveToBuiltinTypeOrDecl(node, 'Boolean');
-        break;
-      case '?':
-      case '!':
-      case '^':
-        this.resolveCollectionPredicate(node, document, extraScopes);
-        break;
-      default:
-        throw Error(`Unsupported binary operator: ${node.operator}`);
+    resolveBinary(node, document, extraScopes) {
+        switch (node.operator) {
+            // TODO: support arithmetics?
+            // case '+':
+            // case '-':
+            // case '*':
+            // case '/':
+            //     this.resolve(node.left, document, extraScopes);
+            //     this.resolve(node.right, document, extraScopes);
+            //     this.resolveToBuiltinTypeOrDecl(node, 'Int');
+            //     break;
+            case '>':
+            case '>=':
+            case '<':
+            case '<=':
+            case '==':
+            case '!=':
+            case '&&':
+            case '||':
+                this.resolve(node.left, document, extraScopes);
+                this.resolve(node.right, document, extraScopes);
+                this.resolveToBuiltinTypeOrDecl(node, 'Boolean');
+                break;
+            case '?':
+            case '!':
+            case '^':
+                this.resolveCollectionPredicate(node, document, extraScopes);
+                break;
+            default:
+                throw Error(`Unsupported binary operator: ${node.operator}`);
+        }
     }
-  }
-  resolveUnary(node, document, extraScopes) {
-    this.resolve(node.operand, document, extraScopes);
-    node.$resolvedType = node.operand.$resolvedType;
-  }
-  resolveReference(node, document, extraScopes) {
-    this.linkReference(node, 'target', document, extraScopes);
-    node.args.forEach(arg => this.resolve(arg, document, extraScopes));
-    if (node.target.ref) {
-      // resolve type
-      if (node.target.ref.$type === _ast.EnumField) {
-        this.resolveToBuiltinTypeOrDecl(node, node.target.ref.$container);
-      } else {
-        this.resolveToDeclaredType(node, node.target.ref.type);
-      }
+    resolveUnary(node, document, extraScopes) {
+        this.resolve(node.operand, document, extraScopes);
+        node.$resolvedType = node.operand.$resolvedType;
     }
-  }
-  resolveArray(node, document, extraScopes) {
-    node.items.forEach(item => this.resolve(item, document, extraScopes));
-    const itemType = node.items[0].$resolvedType;
-    if (itemType !== null && itemType !== void 0 && itemType.decl) {
-      this.resolveToBuiltinTypeOrDecl(node, itemType.decl, true);
+    resolveReference(node, document, extraScopes) {
+        this.linkReference(node, 'target', document, extraScopes);
+        node.args.forEach((arg) => this.resolve(arg, document, extraScopes));
+        if (node.target.ref) {
+            // resolve type
+            if (node.target.ref.$type === ast_1.EnumField) {
+                this.resolveToBuiltinTypeOrDecl(node, node.target.ref.$container);
+            }
+            else {
+                this.resolveToDeclaredType(node, node.target.ref.type);
+            }
+        }
     }
-  }
-  resolveInvocation(node, document, extraScopes) {
-    this.linkReference(node, 'function', document, extraScopes);
-    node.args.forEach(arg => this.resolve(arg, document, extraScopes));
-    if (node.function.ref) {
-      // eslint-disable-next-line @typescript-eslint/ban-types
-      const funcDecl = node.function.ref;
-      if (funcDecl.name === 'auth' && (0, _utils.isFromStdlib)(funcDecl)) {
-        // auth() function is resolved to User model in the current document
-        const model = (0, _utils.getContainingModel)(node);
-        const userModel = model === null || model === void 0 ? void 0 : model.declarations.find(d => (0, _ast.isDataModel)(d) && d.name === 'User');
-        if (userModel) {
-          node.$resolvedType = {
-            decl: userModel
-          };
+    resolveArray(node, document, extraScopes) {
+        node.items.forEach((item) => this.resolve(item, document, extraScopes));
+        const itemType = node.items[0].$resolvedType;
+        if (itemType === null || itemType === void 0 ? void 0 : itemType.decl) {
+            this.resolveToBuiltinTypeOrDecl(node, itemType.decl, true);
         }
-      } else if (funcDecl.name === 'future' && (0, _utils.isFromStdlib)(funcDecl)) {
-        // future() function is resolved to current model
-        node.$resolvedType = {
-          decl: this.getContainingDataModel(node)
-        };
-      } else {
-        this.resolveToDeclaredType(node, funcDecl.returnType);
-      }
     }
-  }
-  getContainingDataModel(node) {
-    let curr = node.$container;
-    while (curr) {
-      if ((0, _ast.isDataModel)(curr)) {
-        return curr;
-      }
-      curr = curr.$container;
+    resolveInvocation(node, document, extraScopes) {
+        this.linkReference(node, 'function', document, extraScopes);
+        node.args.forEach((arg) => this.resolve(arg, document, extraScopes));
+        if (node.function.ref) {
+            // eslint-disable-next-line @typescript-eslint/ban-types
+            const funcDecl = node.function.ref;
+            if (funcDecl.name === 'auth' && (0, utils_1.isFromStdlib)(funcDecl)) {
+                // auth() function is resolved to User model in the current document
+                const model = (0, utils_1.getContainingModel)(node);
+                const userModel = model === null || model === void 0 ? void 0 : model.declarations.find((d) => (0, ast_1.isDataModel)(d) && d.name === 'User');
+                if (userModel) {
+                    node.$resolvedType = { decl: userModel };
+                }
+            }
+            else if (funcDecl.name === 'future' && (0, utils_1.isFromStdlib)(funcDecl)) {
+                // future() function is resolved to current model
+                node.$resolvedType = { decl: this.getContainingDataModel(node) };
+            }
+            else {
+                this.resolveToDeclaredType(node, funcDecl.returnType);
+            }
+        }
     }
-    return undefined;
-  }
-  resolveLiteral(node) {
-    const type = typeof node.value === 'string' ? 'String' : typeof node.value === 'boolean' ? 'Boolean' : typeof node.value === 'number' ? 'Int' : undefined;
-    if (type) {
-      this.resolveToBuiltinTypeOrDecl(node, type);
+    getContainingDataModel(node) {
+        let curr = node.$container;
+        while (curr) {
+            if ((0, ast_1.isDataModel)(curr)) {
+                return curr;
+            }
+            curr = curr.$container;
+        }
+        return undefined;
     }
-  }
-  resolveMemberAccess(node, document, extraScopes) {
-    this.resolve(node.operand, document, extraScopes);
-    const operandResolved = node.operand.$resolvedType;
-    if (operandResolved && !operandResolved.array && (0, _ast.isDataModel)(operandResolved.decl)) {
-      const modelDecl = operandResolved.decl;
-      const provider = name => modelDecl.fields.find(f => f.name === name);
-      extraScopes = [provider, ...extraScopes];
+    resolveLiteral(node) {
+        const type = typeof node.value === 'string'
+            ? 'String'
+            : typeof node.value === 'boolean'
+                ? 'Boolean'
+                : typeof node.value === 'number'
+                    ? 'Int'
+                    : undefined;
+        if (type) {
+            this.resolveToBuiltinTypeOrDecl(node, type);
+        }
     }
-    this.linkReference(node, 'member', document, extraScopes);
-    if (node.member.ref) {
-      this.resolveToDeclaredType(node, node.member.ref.type);
+    resolveMemberAccess(node, document, extraScopes) {
+        this.resolve(node.operand, document, extraScopes);
+        const operandResolved = node.operand.$resolvedType;
+        if (operandResolved && !operandResolved.array && (0, ast_1.isDataModel)(operandResolved.decl)) {
+            const modelDecl = operandResolved.decl;
+            const provider = (name) => modelDecl.fields.find((f) => f.name === name);
+            extraScopes = [provider, ...extraScopes];
+        }
+        this.linkReference(node, 'member', document, extraScopes);
+        if (node.member.ref) {
+            this.resolveToDeclaredType(node, node.member.ref.type);
+        }
     }
-  }
-  resolveCollectionPredicate(node, document, extraScopes) {
-    this.resolve(node.left, document, extraScopes);
-    const resolvedType = node.left.$resolvedType;
-    if (resolvedType && (0, _ast.isDataModel)(resolvedType.decl) && resolvedType.array) {
-      const dataModelDecl = resolvedType.decl;
-      const provider = name => dataModelDecl.fields.find(f => f.name === name);
-      extraScopes = [provider, ...extraScopes];
-      this.resolve(node.right, document, extraScopes);
-      this.resolveToBuiltinTypeOrDecl(node, 'Boolean');
-    } else {
-      // error is reported in validation pass
+    resolveCollectionPredicate(node, document, extraScopes) {
+        this.resolve(node.left, document, extraScopes);
+        const resolvedType = node.left.$resolvedType;
+        if (resolvedType && (0, ast_1.isDataModel)(resolvedType.decl) && resolvedType.array) {
+            const dataModelDecl = resolvedType.decl;
+            const provider = (name) => dataModelDecl.fields.find((f) => f.name === name);
+            extraScopes = [provider, ...extraScopes];
+            this.resolve(node.right, document, extraScopes);
+            this.resolveToBuiltinTypeOrDecl(node, 'Boolean');
+        }
+        else {
+            // error is reported in validation pass
+        }
     }
-  }
-  resolveThis(node,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  document,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  extraScopes) {
-    let decl = node.$container;
-    while (decl && !(0, _ast.isDataModel)(decl)) {
-      decl = decl.$container;
+    resolveThis(node, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    document, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    extraScopes) {
+        let decl = node.$container;
+        while (decl && !(0, ast_1.isDataModel)(decl)) {
+            decl = decl.$container;
+        }
+        if (decl) {
+            this.resolveToBuiltinTypeOrDecl(node, decl);
+        }
     }
-    if (decl) {
-      this.resolveToBuiltinTypeOrDecl(node, decl);
+    resolveNull(node, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    document, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    extraScopes) {
+        // TODO: how to really resolve null?
+        this.resolveToBuiltinTypeOrDecl(node, 'Null');
     }
-  }
-  resolveNull(node,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  document,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  extraScopes) {
-    // TODO: how to really resolve null?
-    this.resolveToBuiltinTypeOrDecl(node, 'Null');
-  }
-  resolveAttributeArg(node, document, extraScopes) {
-    const attrParam = this.findAttrParamForArg(node);
-    const attrAppliedOn = node.$container.$container;
-    if ((attrParam === null || attrParam === void 0 ? void 0 : attrParam.type.type) === 'TransitiveFieldReference' && (0, _ast.isDataModelField)(attrAppliedOn)) {
-      var _attrAppliedOn$type$r;
-      // "TransitiveFieldReference" is resolved in the context of the containing model of the field
-      // where the attribute is applied
-      //
-      // E.g.:
-      //
-      // model A {
-      //   myId @id String
-      // }
-      //
-      // model B {
-      //   id @id String
-      //   a A @relation(fields: [id], references: [myId])
-      // }
-      //
-      // In model B, the attribute argument "myId" is resolved to the field "myId" in model A
-
-      const transtiveDataModel = (_attrAppliedOn$type$r = attrAppliedOn.type.reference) === null || _attrAppliedOn$type$r === void 0 ? void 0 : _attrAppliedOn$type$r.ref;
-      if (transtiveDataModel) {
-        // resolve references in the context of the transitive data model
-        const scopeProvider = name => transtiveDataModel.fields.find(f => f.name === name);
-        if ((0, _ast.isArrayExpr)(node.value)) {
-          var _node$value$items$, _node$value$items$$$r;
-          node.value.items.forEach(item => {
-            if ((0, _ast.isReferenceExpr)(item)) {
-              const resolved = this.resolveFromScopeProviders(item, 'target', document, [scopeProvider]);
-              if (resolved) {
-                this.resolveToDeclaredType(item, resolved.type);
-              } else {
-                // need to clear linked reference, because it's resolved in default scope by default
-                const ref = item.target;
-                ref._ref = this.createLinkingError({
-                  reference: ref,
-                  container: item,
-                  property: 'target'
-                });
-              }
+    resolveAttributeArg(node, document, extraScopes) {
+        var _a, _b, _c;
+        const attrParam = this.findAttrParamForArg(node);
+        const attrAppliedOn = node.$container.$container;
+        if ((attrParam === null || attrParam === void 0 ? void 0 : attrParam.type.type) === 'TransitiveFieldReference' && (0, ast_1.isDataModelField)(attrAppliedOn)) {
+            // "TransitiveFieldReference" is resolved in the context of the containing model of the field
+            // where the attribute is applied
+            //
+            // E.g.:
+            //
+            // model A {
+            //   myId @id String
+            // }
+            //
+            // model B {
+            //   id @id String
+            //   a A @relation(fields: [id], references: [myId])
+            // }
+            //
+            // In model B, the attribute argument "myId" is resolved to the field "myId" in model A
+            const transtiveDataModel = (_a = attrAppliedOn.type.reference) === null || _a === void 0 ? void 0 : _a.ref;
+            if (transtiveDataModel) {
+                // resolve references in the context of the transitive data model
+                const scopeProvider = (name) => transtiveDataModel.fields.find((f) => f.name === name);
+                if ((0, ast_1.isArrayExpr)(node.value)) {
+                    node.value.items.forEach((item) => {
+                        if ((0, ast_1.isReferenceExpr)(item)) {
+                            const resolved = this.resolveFromScopeProviders(item, 'target', document, [scopeProvider]);
+                            if (resolved) {
+                                this.resolveToDeclaredType(item, resolved.type);
+                            }
+                            else {
+                                // need to clear linked reference, because it's resolved in default scope by default
+                                const ref = item.target;
+                                ref._ref = this.createLinkingError({
+                                    reference: ref,
+                                    container: item,
+                                    property: 'target',
+                                });
+                            }
+                        }
+                    });
+                    if ((_c = (_b = node.value.items[0]) === null || _b === void 0 ? void 0 : _b.$resolvedType) === null || _c === void 0 ? void 0 : _c.decl) {
+                        this.resolveToBuiltinTypeOrDecl(node.value, node.value.items[0].$resolvedType.decl, true);
+                    }
+                }
+                else if ((0, ast_1.isReferenceExpr)(node.value)) {
+                    const resolved = this.resolveFromScopeProviders(node.value, 'target', document, [scopeProvider]);
+                    if (resolved) {
+                        this.resolveToDeclaredType(node.value, resolved.type);
+                    }
+                    else {
+                        // need to clear linked reference, because it's resolved in default scope by default
+                        const ref = node.value.target;
+                        ref._ref = this.createLinkingError({
+                            reference: ref,
+                            container: node.value,
+                            property: 'target',
+                        });
+                    }
+                }
             }
-          });
-          if ((_node$value$items$ = node.value.items[0]) !== null && _node$value$items$ !== void 0 && (_node$value$items$$$r = _node$value$items$.$resolvedType) !== null && _node$value$items$$$r !== void 0 && _node$value$items$$$r.decl) {
-            this.resolveToBuiltinTypeOrDecl(node.value, node.value.items[0].$resolvedType.decl, true);
-          }
-        } else if ((0, _ast.isReferenceExpr)(node.value)) {
-          const resolved = this.resolveFromScopeProviders(node.value, 'target', document, [scopeProvider]);
-          if (resolved) {
-            this.resolveToDeclaredType(node.value, resolved.type);
-          } else {
-            // need to clear linked reference, because it's resolved in default scope by default
-            const ref = node.value.target;
-            ref._ref = this.createLinkingError({
-              reference: ref,
-              container: node.value,
-              property: 'target'
-            });
-          }
         }
-      }
-    } else {
-      this.resolve(node.value, document, extraScopes);
-    }
-    node.$resolvedType = node.value.$resolvedType;
-  }
-  findAttrParamForArg(arg) {
-    const attr = arg.$container.decl.ref;
-    if (!attr) {
-      return undefined;
+        else {
+            this.resolve(node.value, document, extraScopes);
+        }
+        node.$resolvedType = node.value.$resolvedType;
     }
-    if (arg.name) {
-      var _attr$params;
-      return (_attr$params = attr.params) === null || _attr$params === void 0 ? void 0 : _attr$params.find(p => p.name === arg.name);
-    } else {
-      const index = arg.$container.args.findIndex(a => a === arg);
-      return attr.params[index];
+    findAttrParamForArg(arg) {
+        var _a;
+        const attr = arg.$container.decl.ref;
+        if (!attr) {
+            return undefined;
+        }
+        if (arg.name) {
+            return (_a = attr.params) === null || _a === void 0 ? void 0 : _a.find((p) => p.name === arg.name);
+        }
+        else {
+            const index = arg.$container.args.findIndex((a) => a === arg);
+            return attr.params[index];
+        }
     }
-  }
-  resolveDefault(node, document, extraScopes) {
-    for (const [property, value] of Object.entries(node)) {
-      if (!property.startsWith('$')) {
-        if ((0, _langium.isReference)(value)) {
-          this.linkReference(node, property, document, extraScopes);
+    resolveDefault(node, document, extraScopes) {
+        for (const [property, value] of Object.entries(node)) {
+            if (!property.startsWith('$')) {
+                if ((0, langium_1.isReference)(value)) {
+                    this.linkReference(node, property, document, extraScopes);
+                }
+            }
+        }
+        for (const child of (0, langium_1.streamContents)(node)) {
+            this.resolve(child, document, extraScopes);
         }
-      }
     }
-    for (const child of (0, _langium.streamContents)(node)) {
-      this.resolve(child, document, extraScopes);
+    //#endregion
+    //#region Utils
+    resolveToDeclaredType(node, type) {
+        if (type.type) {
+            const mappedType = (0, utils_2.mapBuiltinTypeToExpressionType)(type.type);
+            node.$resolvedType = { decl: mappedType, array: type.array };
+        }
+        else if (type.reference) {
+            node.$resolvedType = {
+                decl: type.reference.ref,
+                array: type.array,
+            };
+        }
     }
-  }
-
-  //#endregion
-
-  //#region Utils
-
-  resolveToDeclaredType(node, type) {
-    if (type.type) {
-      const mappedType = (0, _utils2.mapBuiltinTypeToExpressionType)(type.type);
-      node.$resolvedType = {
-        decl: mappedType,
-        array: type.array
-      };
-    } else if (type.reference) {
-      node.$resolvedType = {
-        decl: type.reference.ref,
-        array: type.array
-      };
+    resolveToBuiltinTypeOrDecl(node, type, array = false) {
+        node.$resolvedType = { decl: type, array };
     }
-  }
-  resolveToBuiltinTypeOrDecl(node, type, array = false) {
-    node.$resolvedType = {
-      decl: type,
-      array
-    };
-  }
-
-  //#endregion
 }
 exports.ZModelLinker = ZModelLinker;
 //# sourceMappingURL=zmodel-linker.js.map