fix: link invoked alias to its declaration

Author: Azzerty23

packages/schema/src/language-server/validator/attribute-application-validator.ts

@@ -8,6 +8,7 @@ import {
     DataModelFieldAttribute,
     InternalAttribute,
     ReferenceExpr,
+    isAliasDecl,
     isArrayExpr,
     isAttribute,
     isDataModel,
@@ -28,7 +29,12 @@ import {
 import { ValidationAcceptor, streamAllContents, streamAst } from 'langium';
 import pluralize from 'pluralize';
 import { AstValidator } from '../types';
-import { getStringLiteral, mapBuiltinTypeToExpressionType, typeAssignable } from './utils';
+import {
+    getStringLiteral,
+    mapBuiltinTypeToExpressionType,
+    mappedRawExpressionTypeToResolvedShape,
+    typeAssignable,
+} from './utils';
 
 // a registry of function handlers marked with @check
 const attributeCheckers = new Map<string, PropertyDescriptor>();
@@ -264,6 +270,16 @@ function assignableToAttributeParam(arg: AttributeArg, param: AttributeParam, at
     let dstType = param.type.type;
     let dstIsArray = param.type.array;
 
+    if (isAliasDecl(arg.$resolvedType?.decl)) {
+        if (dstType === 'ContextType') {
+            // TODO: what is context type? Passed to true to avoid error, to be fixed later
+            return true;
+        }
+        const aliasExpression = arg.$resolvedType.decl.expression;
+        const mappedType = mappedRawExpressionTypeToResolvedShape(aliasExpression.$type);
+        return dstType === mappedType;
+    }
+
     if (dstType === 'ContextType') {
         // ContextType is inferred from the attribute's container's type
         if (isDataModelField(attr.$container)) {

packages/schema/src/language-server/validator/expression-validator.ts

@@ -50,9 +50,9 @@ export default class ExpressionValidator implements AstValidator<Expression> {
                     }
                     return false;
                 });
-                if (!hasReferenceResolutionError) {
+                if (hasReferenceResolutionError) {
                     // report silent errors not involving linker errors
-                    accept('error', 'Expression cannot be resolved', {
+                    accept('error', `Expression cannot be resolved: ${expr.$cstNode?.text}`, {
                         node: expr,
                     });
                 }

packages/schema/src/language-server/zmodel-linker.ts

@@ -67,7 +67,7 @@ import {
     isAliasInvocation,
 } from '../utils/ast-utils';
 import { isMemberContainer } from './utils';
-import { mapBuiltinTypeToExpressionType, mappedRawExpressionTypeToResolvedShape } from './validator/utils';
+import { mapBuiltinTypeToExpressionType } from './validator/utils';
 
 interface DefaultReference extends Reference {
     _ref?: AstNode | LinkingError;
@@ -312,19 +312,18 @@ export class ZModelLinker extends DefaultLinker {
             } else if (isFutureExpr(node)) {
                 // future() function is resolved to current model
                 node.$resolvedType = { decl: getContainingDataModel(node) };
-            } else if (isAliasInvocation(node) || !!getContainerOfType(node, isAliasDecl)) {
+            } else if (isAliasInvocation(node)) {
                 // function is resolved to matching alias declaration
-                const expressionType = funcDecl.expression?.$type;
-                if (!expressionType) {
-                    this.createLinkingError({
-                        reference: node.function,
-                        container: node,
-                        property: 'alias',
-                    });
-                    return;
+                const containingAlias = getContainerOfType(node, isAliasDecl);
+                const allAlias = getContainerOfType(node, isModel)?.declarations.filter(isAliasDecl) ?? [];
+                const matchingAlias =
+                    isAliasInvocation(node) && !containingAlias
+                        ? allAlias.find((alias) => alias.name === node.function.$refText)
+                        : containingAlias;
+
+                if (matchingAlias) {
+                    node.$resolvedType = { decl: matchingAlias, nullable: false };
                 }
-                const mappedType = mappedRawExpressionTypeToResolvedShape(expressionType);
-                this.resolveToBuiltinTypeOrDecl(node, mappedType);
             } else {
                 this.resolveToDeclaredType(node, (funcDecl as FunctionDecl).returnType);
             }

packages/schema/src/language-server/zmodel-semantic.ts

@@ -1,4 +1,5 @@
 import {
+    isAliasDecl,
     isAttribute,
     isAttributeArg,
     isConfigField,
@@ -83,7 +84,7 @@ export class ZModelSemanticTokenProvider extends AbstractSemanticTokenProvider {
                 property: 'function',
                 type: SemanticTokenTypes.function,
             });
-        } else if (isFunctionDecl(node) || isAttribute(node)) {
+        } else if (isFunctionDecl(node) || isAliasDecl(node) || isAttribute(node)) {
             acceptor({
                 node,
                 property: 'name',

packages/schema/src/plugins/enhancer/policy/utils.ts

@@ -14,8 +14,8 @@ import {
     getIdFields,
     getLiteral,
     getQueryGuardFunctionName,
-    isAuthInvocation,
     hasAuthInvocation,
+    isAuthInvocation,
     isDataModelFieldReference,
     isEnumFieldReference,
     isFromStdlib,

packages/sdk/src/utils.ts

@@ -14,7 +14,7 @@ import {
     FunctionDecl,
     GeneratorDecl,
     InternalAttribute,
-    InvocationExpr,
+    isAliasDecl,
     isArrayExpr,
     isConfigArrayExpr,
     isDataModel,
@@ -41,6 +41,7 @@ import fs from 'node:fs';
 import path from 'path';
 import { ExpressionContext, STD_LIB_MODULE_NAME } from './constants';
 import { PluginError, type PluginDeclaredOptions, type PluginOptions } from './types';
+import { streamAst } from 'langium';
 
 /**
  * Gets data models in the ZModel schema.
@@ -457,10 +458,13 @@ export function isAuthInvocation(node: AstNode) {
 }
 
 export function hasAuthInvocation(node: AstNode) {
-    return (
-        isAuthInvocation(node) ||
-        (isAliasExpr(node) && (node as InvocationExpr).function?.ref?.expression?.$cstNode?.text.includes('auth()'))
-    );
+    return streamAst(node).some((node) => {
+        const hasAuth =
+            isAuthInvocation(node) ||
+            (isAliasDecl(node.$resolvedType?.decl) &&
+                node.$resolvedType?.decl.expression?.$cstNode?.text.includes('auth()'));
+        return hasAuth;
+    });
 }
 
 export function isFromStdlib(node: AstNode) {

tests/integration/tests/plugins/policy.test.ts

@@ -112,7 +112,7 @@ model M {
     });
 
     it('alias expressions', async () => {
-        const { policy, projectDir } = await loadSchema(
+        const { policy } = await loadSchema(
             `
             alias allowAll() {
                 true