@typespec/compiler 1.10.0-dev.2 → 1.10.0-dev.4

package/dist/src/core/checker.js

@@ -7,12 +7,12 @@ import { createSymbol, getSymNode } from "./binder.js";
 import { createChangeIdentifierCodeFix } from "./compiler-code-fixes/change-identifier.codefix.js";
 import { createModelToObjectValueCodeFix, createTupleToArrayValueCodeFix, } from "./compiler-code-fixes/convert-to-value.codefix.js";
 import { getDeprecationDetails, markDeprecated } from "./deprecation.js";
-import { compilerAssert, ignoreDiagnostics, reportDeprecated } from "./diagnostics.js";
+import { compilerAssert, createDiagnosticCollector, ignoreDiagnostics, reportDeprecated, } from "./diagnostics.js";
 import { validateInheritanceDiscriminatedUnions } from "./helpers/discriminator-utils.js";
 import { explainStringTemplateNotSerializable } from "./helpers/string-template-utils.js";
 import { typeReferenceToString } from "./helpers/syntax-utils.js";
 import { getEntityName, getTypeName } from "./helpers/type-name-utils.js";
-import { marshallTypeForJS } from "./js-marshaller.js";
+import { marshalTypeForJs, unmarshalJsToValue } from "./js-marshaller.js";
 import { createDiagnostic } from "./messages.js";
 import { Numeric } from "./numeric.js";
 import { exprIsBareIdentifier, getFirstAncestor, getIdentifierContext, hasParseError, visitChildren, } from "./parser.js";
@@ -175,6 +175,7 @@ export function createChecker(program, resolver) {
         nullType,
         anyType: unknownType,
         voidType,
+        unknownType,
         typePrototype,
         createType,
         createAndFinishType,
@@ -346,7 +347,7 @@ export function createChecker(program, resolver) {
     function getValueForNode(node, mapperOrContext, constraint) {
         const ctx = CheckContext.from(mapperOrContext);
         const initial = checkNode(ctx, node, constraint);
-        if (initial === null) {
+        if (initial === null || initial === errorType) {
             return null;
         }
         let entity;
@@ -360,6 +361,8 @@ export function createChecker(program, resolver) {
             return null;
         }
         if (isValue(entity)) {
+            if (entity.valueKind === "Function")
+                return entity;
             return constraint ? inferScalarsFromConstraints(entity, constraint.type) : entity;
         }
         // If a template parameter that can be a value is used in a template declaration then we allow it but we return null because we don't have an actual value.
@@ -420,9 +423,8 @@ export function createChecker(program, resolver) {
             case "UnionVariant":
                 return getValueFromIndeterminate(type.type, constraint, node);
             case "Intrinsic":
-                switch (type.name) {
-                    case "null":
-                        return checkNullValue(type, constraint, node);
+                if (type.name === "null") {
+                    return checkNullValue(type, constraint, node);
                 }
                 return type;
             default:
@@ -477,8 +479,8 @@ export function createChecker(program, resolver) {
      * For nodes that can be both type or values(e.g. string), the value will be returned if the constraint expect a value of that type even if the constrain also allows the type.
      * This means that if the constraint is `string | valueof string` passing `"abc"` will send the value `"abc"` and not the type `"abc"`.
      */
-    function getTypeOrValueForNode(node, mapper, constraint) {
-        const ctx = CheckContext.from(mapper);
+    function getTypeOrValueForNode(node, contextOrMapper, constraint) {
+        const ctx = CheckContext.from(contextOrMapper);
         const valueConstraint = extractValueOfConstraints(constraint);
         const entity = checkNode(ctx, node, valueConstraint);
         if (entity === null) {
@@ -507,6 +509,12 @@ export function createChecker(program, resolver) {
                 reportCheckerDiagnostics(valueDiagnostics);
                 return result;
             }
+            else {
+                const canBeType = constraint?.constraint.type !== undefined;
+                // If the node _must_ resolve to a value, we will return it unconstrained, so that we will at least produce
+                // a value. If it _can_ be a type, we already failed the value constraint, so we return the type as is.
+                return canBeType ? entity.type : getValueFromIndeterminate(entity.type, undefined, node);
+            }
         }
         return entity.type;
     }
@@ -571,6 +579,8 @@ export function createChecker(program, resolver) {
                 return checkDecoratorDeclaration(ctx, node);
             case SyntaxKind.FunctionDeclarationStatement:
                 return checkFunctionDeclaration(ctx, node);
+            case SyntaxKind.FunctionTypeExpression:
+                return checkFunctionTypeExpression(ctx, node);
             case SyntaxKind.TypeReference:
                 return checkTypeOrValueReference(ctx, node);
             case SyntaxKind.TemplateArgument:
@@ -711,6 +721,7 @@ export function createChecker(program, resolver) {
      * @param node Node.
      * @param mapper Type mapper for template instantiation context.
      * @param instantiateTemplate If templated type should be instantiated if they haven't yet.
+     * @param allowFunctions If functions are allowed as types.
      * @returns Resolved type.
      */
     function checkTypeReference(ctx, node, instantiateTemplate = true) {
@@ -726,6 +737,7 @@ export function createChecker(program, resolver) {
      * @param node Node.
      * @param mapper Type mapper for template instantiation context.
      * @param instantiateTemplate If templated type should be instantiated if they haven't yet.
+     * @param allowFunctions If functions are allowed as types.
      * @returns Resolved type.
      */
     function checkTypeOrValueReference(ctx, node, instantiateTemplate = true) {
@@ -953,6 +965,7 @@ export function createChecker(program, resolver) {
      * @param node Node
      * @param mapper Type mapper for template instantiation context.
      * @param instantiateTemplates If a templated type should be instantiated if not yet @default true
+     * @param allowFunctions If functions are allowed as types. @default false
      * @returns resolved type.
      */
     function checkTypeReferenceSymbol(ctx, sym, node, instantiateTemplates = true) {
@@ -983,8 +996,7 @@ export function createChecker(program, resolver) {
             return errorType;
         }
         if (sym.flags & 2048 /* SymbolFlags.Function */) {
-            reportCheckerDiagnostic(createDiagnostic({ code: "invalid-type-ref", messageId: "function", target: sym }));
-            return errorType;
+            return getValueForNode(sym.declarations[0], ctx);
         }
         const argumentNodes = node.kind === SyntaxKind.TypeReference ? node.arguments : [];
         const symbolLinks = getSymbolLinks(sym);
@@ -1141,7 +1153,7 @@ export function createChecker(program, resolver) {
     function checkDeclaredType(ctx, sym, node) {
         return getTypeForTypeOrIndeterminate(checkDeclaredTypeOrIndeterminate(ctx, sym, node));
     }
-    function getOrInstantiateTemplate(ctx, templateNode, params, args, source, parentMapper, instantiateTempalates = true) {
+    function getOrInstantiateTemplate(ctx, templateNode, params, args, source, parentMapper, instantiateTemplates = true) {
         const symbolLinks = templateNode.kind === SyntaxKind.OperationStatement &&
             templateNode.parent.kind === SyntaxKind.InterfaceStatement
             ? getSymbolLinksForMember(templateNode)
@@ -1161,7 +1173,7 @@ export function createChecker(program, resolver) {
         if (cached) {
             return cached;
         }
-        if (instantiateTempalates) {
+        if (instantiateTemplates) {
             return instantiateTemplate(ctx.withMapper(mapper), symbolLinks.instantiations, templateNode, params);
         }
         else {
@@ -1355,8 +1367,69 @@ export function createChecker(program, resolver) {
         return decoratorType;
     }
     function checkFunctionDeclaration(ctx, node) {
-        reportCheckerDiagnostic(createDiagnostic({ code: "function-unsupported", target: node }));
-        return errorType;
+        const mergedSymbol = getMergedSymbol(node.symbol);
+        const links = getSymbolLinks(mergedSymbol);
+        if (links.value !== undefined) {
+            return links.value;
+        }
+        reportCheckerDiagnostic(createDiagnostic({
+            code: "experimental-feature",
+            messageId: "functionDeclarations",
+            target: node,
+        }));
+        const namespace = getParentNamespaceType(node);
+        compilerAssert(namespace, `Function ${node.id.sv} should have resolved a declared namespace or the global namespace.`);
+        const name = node.id.sv;
+        if (!(node.modifierFlags & 2 /* ModifierFlags.Extern */)) {
+            reportCheckerDiagnostic(createDiagnostic({ code: "function-extern", target: node }));
+        }
+        const implementation = mergedSymbol.value;
+        if (implementation === undefined) {
+            reportCheckerDiagnostic(createDiagnostic({ code: "missing-implementation", target: node }));
+        }
+        const parameters = node.parameters.map((x) => checkFunctionParameter(ctx, x, true));
+        const returnType = node.returnType
+            ? getParamConstraintEntityForNode(ctx, node.returnType)
+            : {
+                entityKind: "MixedParameterConstraint",
+                type: unknownType,
+            };
+        const functionValue = createValue({
+            entityKind: "Value",
+            valueKind: "Function",
+            name,
+            type: createAndFinishType({
+                kind: "FunctionType",
+                parameters,
+                returnType,
+            }),
+            parameters,
+            returnType,
+            namespace,
+            node,
+            implementation: implementation ??
+                Object.assign(() => getDefaultFunctionResult(returnType), {
+                    isDefaultFunctionImplementation: true,
+                }),
+        }, unknownType);
+        namespace.functionDeclarations.set(name, functionValue);
+        links.value = functionValue;
+        return functionValue;
+    }
+    function checkFunctionTypeExpression(ctx, node) {
+        const parameters = node.parameters.map((param) => checkFunctionParameter(ctx, param, true));
+        const returnType = node.returnType
+            ? getParamConstraintEntityForNode(ctx, node.returnType)
+            : {
+                entityKind: "MixedParameterConstraint",
+                type: unknownType,
+            };
+        return createAndFinishType({
+            kind: "FunctionType",
+            node,
+            parameters,
+            returnType,
+        });
     }
     function checkFunctionParameter(ctx, node, mixed) {
         const links = getSymbolLinks(node.symbol);
@@ -1979,7 +2052,7 @@ export function createChecker(program, resolver) {
                 return undefined;
             }
             const ctorType = checkCallExpressionTarget(CheckContext.DEFAULT, callExpNode);
-            if (ctorType?.kind !== "ScalarConstructor") {
+            if (ctorType?.entityKind !== "Type" || ctorType?.kind !== "ScalarConstructor") {
                 return undefined;
             }
             const argIndex = callExpNode.arguments.findIndex((n) => n === argNode);
@@ -2209,12 +2282,15 @@ export function createChecker(program, resolver) {
                 case IdentifierKind.Decorator:
                     // Only return decorators and namespaces when completing decorator
                     return !!(sym.flags & (512 /* SymbolFlags.Decorator */ | 256 /* SymbolFlags.Namespace */));
+                case IdentifierKind.Function:
+                    // Only return functions and namespaces when completing function calls
+                    return !!(sym.flags & (2048 /* SymbolFlags.Function */ | 256 /* SymbolFlags.Namespace */));
                 case IdentifierKind.Using:
                     // Only return namespaces when completing using
                     return !!(sym.flags & 256 /* SymbolFlags.Namespace */);
                 case IdentifierKind.TypeReference:
-                    // Do not return functions or decorators when completing types
-                    return !(sym.flags & (2048 /* SymbolFlags.Function */ | 512 /* SymbolFlags.Decorator */));
+                    // Do not return decorators when completing types
+                    return !(sym.flags & 512 /* SymbolFlags.Decorator */);
                 case IdentifierKind.TemplateArgument:
                     return !!(sym.flags & 1024 /* SymbolFlags.TemplateParameter */);
                 default:
@@ -3129,17 +3205,68 @@ export function createChecker(program, resolver) {
         }, literalType);
     }
     function checkCallExpressionTarget(ctx, node) {
-        const target = checkTypeReference(ctx, node.target);
-        if (target.kind === "Scalar" || target.kind === "ScalarConstructor") {
-            return target;
+        const target = checkTypeOrValueReference(ctx, node.target);
+        if (target.entityKind === "Type") {
+            if (target.kind === "Scalar" || target.kind === "ScalarConstructor") {
+                return target;
+            }
+            else if (target.kind === "TemplateParameter") {
+                const callable = target.constraint && constraintIsCallable(target.constraint);
+                if (!callable) {
+                    reportCheckerDiagnostic(createDiagnostic({
+                        code: "non-callable",
+                        messageId: "templateParameter",
+                        format: {
+                            name: target.node.id.sv,
+                            constraint: target.constraint
+                                ? getEntityName(target.constraint, { printable: true })
+                                : "unknown",
+                        },
+                        target: node.target,
+                    }));
+                }
+                return null;
+            }
         }
-        else {
+        else if (target.entityKind === "Value") {
+            if (target.valueKind === "Function") {
+                return target;
+            }
+        }
+        const kind = target.entityKind === "Type"
+            ? target.kind
+            : target.entityKind === "Indeterminate"
+                ? target.type.kind
+                : target.valueKind;
+        if (!isErrorType(target)) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "non-callable",
-                format: { type: target.kind },
+                format: { type: kind },
                 target: node.target,
             }));
-            return null;
+        }
+        return null;
+        function constraintIsCallable(constraint) {
+            compilerAssert(constraint.type || constraint.valueType, "Expected constraint to have type or value type");
+            let callable = true;
+            if (constraint.type) {
+                callable &&= typeIsCallable(constraint.type);
+            }
+            if (constraint.valueType) {
+                callable &&= constraint.valueType.kind === "FunctionType";
+            }
+            return callable;
+        }
+        function typeIsCallable(type) {
+            switch (type.kind) {
+                case "Scalar":
+                case "ScalarConstructor":
+                    return true;
+                case "Union":
+                    return [...type.variants.values()].every(typeIsCallable);
+                default:
+                    return false;
+            }
         }
     }
     /** Check the arguments of the call expression are a single value of the given syntax. */
@@ -3264,9 +3391,13 @@ export function createChecker(program, resolver) {
         if (target === null) {
             return null;
         }
-        if (target.kind === "ScalarConstructor") {
+        if (target.entityKind === "Type" && target.kind === "ScalarConstructor") {
             return createScalarValue(ctx, node, target);
         }
+        else if (target.entityKind === "Value" && target.valueKind === "Function") {
+            return checkFunctionCall(ctx, node, target);
+        }
+        compilerAssert(target.entityKind === "Type", "Expected type entity");
         if (relation.areScalarsRelated(target, getStdType("string"))) {
             return checkPrimitiveArg(node, target, "StringValue");
         }
@@ -3285,6 +3416,264 @@ export function createChecker(program, resolver) {
             return null;
         }
     }
+    function checkFunctionCall(ctx, node, target) {
+        const [satisfied, resolvedArgs] = checkFunctionCallArguments(ctx, node.arguments, target);
+        const canCall = satisfied &&
+            !ctx.hasFlags(CheckFlags.InTemplateDeclaration) &&
+            !target.implementation.isDefaultFunctionImplementation;
+        const fnCtx = createFunctionContext(program, node);
+        if (!canCall) {
+            return getDefaultFunctionResult(target.returnType);
+        }
+        const functionReturn = target.implementation(fnCtx, ...resolvedArgs);
+        const returnIsEntity = typeof functionReturn === "object" &&
+            functionReturn !== null &&
+            "entityKind" in functionReturn &&
+            (functionReturn.entityKind === "Type" ||
+                functionReturn.entityKind === "Value" ||
+                functionReturn.entityKind === "Indeterminate");
+        // special case for when the return value is `undefined` and the return type is `void` or `valueof void`.
+        if (functionReturn === undefined && isVoidReturn(target.returnType)) {
+            return voidType;
+        }
+        const unmarshaled = returnIsEntity
+            ? functionReturn
+            : unmarshalJsToValue(program, functionReturn, function onInvalid(value) {
+                let valueSummary = String(value);
+                if (valueSummary.length > 30) {
+                    valueSummary = valueSummary.slice(0, 27) + "...";
+                }
+                reportCheckerDiagnostic(createDiagnostic({
+                    code: "function-return",
+                    messageId: "invalid-value",
+                    format: { value: valueSummary },
+                    target: node,
+                }));
+            });
+        let result = unmarshaled;
+        if (satisfied && result !== null)
+            result = checkFunctionReturn(target, result, node);
+        return result;
+    }
+    function isVoidReturn(constraint) {
+        if (constraint.valueType) {
+            return false;
+        }
+        if (constraint.type) {
+            if (!isVoidType(constraint.type))
+                return false;
+        }
+        return true;
+        function isVoidType(type) {
+            return type.kind === "Intrinsic" && type.name === "void";
+        }
+    }
+    /**
+     * Produces the default function result when a function call cannot be completed.
+     *
+     * This produces `null` if the function has a value type constraint but no type constraint, `errorType`
+     * otherwise (if the function _could_ return a Type).
+     *
+     * @param constraint - The function return constraint.
+     * @returns
+     */
+    function getDefaultFunctionResult(constraint) {
+        if (constraint.valueType) {
+            // If the function _can_ return a value, we will just return null. This is a bit of a hack, but it's the best fallback
+            // for a function that could return a type or value, since returning a type would cause type-in-value errors.
+            return null;
+        }
+        else {
+            compilerAssert(constraint.type, "Expected function to have a return type when it did not have a value type constraint");
+            // If for some reason we cannot evaluate the call, we will return the type constraint itself as a fallback.
+            // This is the strongest thing we can do in the context of an error or a template declaration, since the result
+            // of the function call must be assignable to the constraint, and by the transitive property if the constraint
+            // is assignable in the context of evaluation, so will be the result of any valid evaluation of the implementation.
+            // Technically, this isn't exactly ideal, since it could prevent function calls that return subtypes of the constraint
+            // from assigning if the _result_ would be assignable. However, we have other cases where we check constraints in
+            // templates to try to ensure that any instance will validate. We may need to revisit this in the future, but for
+            // now, I am choosing strictness in the face of uncertainty.
+            return constraint.type;
+        }
+    }
+    function checkFunctionCallArguments(ctx, args, target) {
+        let satisfied = true;
+        const minArgs = target.parameters.filter((p) => !p.optional && !p.rest).length;
+        const maxArgs = target.parameters[target.parameters.length - 1]?.rest
+            ? undefined
+            : target.parameters.length;
+        if (args.length < minArgs) {
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "invalid-argument-count",
+                messageId: "atLeast",
+                format: { actual: args.length.toString(), expected: minArgs.toString() },
+                target: target.node,
+            }));
+            return [false, []];
+        }
+        else if (maxArgs !== undefined && args.length > maxArgs) {
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "invalid-argument-count",
+                format: { actual: args.length.toString(), expected: maxArgs.toString() },
+                target: target.node,
+            }));
+            // This error doesn't actually prevent us from checking the arguments and evaluating the function.
+        }
+        const collector = createDiagnosticCollector();
+        const resolvedArgs = [];
+        let idx = 0;
+        for (const param of target.parameters) {
+            if (param.rest) {
+                const constraint = extractRestParamConstraint(param.type);
+                if (!constraint) {
+                    satisfied = false;
+                    continue;
+                }
+                const restArgExpressions = args.slice(idx);
+                const restArgs = restArgExpressions.map((arg) => getTypeOrValueForNode(arg, ctx, { kind: "argument", constraint }));
+                if (restArgs.some((x) => x === null)) {
+                    satisfied = false;
+                    continue;
+                }
+                resolvedArgs.push(...restArgs.map((v, idx) => v !== null && isValue(v) ? marshalTypeForJs(v, undefined) : v));
+            }
+            else {
+                const arg = args[idx++];
+                if (!arg) {
+                    if (param.optional) {
+                        resolvedArgs.push(undefined);
+                        continue;
+                    }
+                    else {
+                        // No need to report a diagnostic here because we already reported one for
+                        // invalid argument counts above.
+                        satisfied = false;
+                        continue;
+                    }
+                }
+                // Normal param
+                const checkedArg = getTypeOrValueForNode(arg, ctx, {
+                    kind: "argument",
+                    constraint: param.type,
+                });
+                if (!checkedArg) {
+                    satisfied = false;
+                    continue;
+                }
+                const resolved = collector.pipe(checkEntityAssignableToConstraint(checkedArg, param.type, arg));
+                satisfied &&= !!resolved;
+                resolvedArgs.push(resolved
+                    ? isValue(resolved)
+                        ? marshalTypeForJs(resolved, undefined)
+                        : resolved
+                    : undefined);
+            }
+        }
+        reportCheckerDiagnostics(collector.diagnostics);
+        return [satisfied, resolvedArgs];
+    }
+    function checkFunctionReturn(target, result, diagnosticTarget) {
+        const [checked, diagnostics] = checkEntityAssignableToConstraint(result, target.returnType, diagnosticTarget);
+        if (diagnostics.length > 0) {
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "function-return",
+                messageId: "unassignable",
+                format: {
+                    name: getEntityName(target, { printable: true }),
+                    entityKind: result.entityKind.toLowerCase(),
+                    return: getEntityName(result, { printable: true }),
+                    type: getEntityName(target.returnType, { printable: true }),
+                },
+                target: diagnosticTarget,
+            }));
+        }
+        return checked;
+    }
+    function checkEntityAssignableToConstraint(entity, constraint, diagnosticTarget) {
+        const constraintIsValue = !!constraint.valueType;
+        const constraintIsType = !!constraint.type;
+        const collector = createDiagnosticCollector();
+        switch (true) {
+            case constraintIsValue && constraintIsType: {
+                const tried = tryAssignValue();
+                if (tried[0] !== null || entity.entityKind === "Value") {
+                    // Succeeded as value or is a value
+                    return tried;
+                }
+                // Now we are guaranteed a type.
+                const typeEntity = entity.entityKind === "Indeterminate" ? entity.type : entity;
+                const assignable = collector.pipe(relation.isTypeAssignableTo(typeEntity, constraint.type, diagnosticTarget));
+                return collector.wrap(assignable ? typeEntity : null);
+            }
+            case constraintIsValue: {
+                const normed = collector.pipe(normalizeValue(entity, constraint, diagnosticTarget));
+                // Error should have been reported in normalizeValue
+                if (!normed)
+                    return collector.wrap(null);
+                const assignable = collector.pipe(relation.isValueOfType(normed, constraint.valueType, diagnosticTarget));
+                return collector.wrap(assignable ? normed : null);
+            }
+            case constraintIsType: {
+                if (entity.entityKind === "Indeterminate")
+                    entity = entity.type;
+                if (entity.entityKind !== "Type") {
+                    collector.add(createDiagnostic({
+                        code: "value-in-type",
+                        format: { name: getTypeName(entity.type) },
+                        target: diagnosticTarget,
+                    }));
+                    return collector.wrap(null);
+                }
+                const assignable = collector.pipe(relation.isTypeAssignableTo(entity, constraint.type, diagnosticTarget));
+                return collector.wrap(assignable ? entity : null);
+            }
+            default: {
+                compilerAssert(false, "Expected at least one of type or value constraint to be defined.");
+            }
+        }
+        function tryAssignValue() {
+            const collector = createDiagnosticCollector();
+            const normed = collector.pipe(normalizeValue(entity, constraint, diagnosticTarget));
+            const assignable = normed
+                ? collector.pipe(relation.isValueOfType(normed, constraint.valueType, diagnosticTarget))
+                : false;
+            return collector.wrap(assignable ? normed : null);
+        }
+    }
+    function normalizeValue(entity, constraint, diagnosticTarget) {
+        if (entity.entityKind === "Value")
+            return [entity, []];
+        if (entity.entityKind === "Indeterminate") {
+            // Coerce to a value
+            const coerced = getValueFromIndeterminate(entity.type, constraint.type && { kind: "argument", type: constraint.type }, entity.type.node);
+            if (coerced?.entityKind !== "Value") {
+                return [
+                    null,
+                    [
+                        createDiagnostic({
+                            code: "expect-value",
+                            format: { name: getTypeName(entity.type) },
+                            target: diagnosticTarget,
+                        }),
+                    ],
+                ];
+            }
+            return [coerced, []];
+        }
+        if (entity.entityKind === "Type") {
+            return [
+                null,
+                [
+                    createDiagnostic({
+                        code: "expect-value",
+                        format: { name: getTypeName(entity) },
+                        target: diagnosticTarget,
+                    }),
+                ],
+            ];
+        }
+        compilerAssert(false, `Unreachable: unexpected entity kind '${entity.entityKind}'`);
+    }
     function checkTypeOfExpression(ctx, node) {
         const entity = checkNode(ctx, node.target, undefined);
         if (entity === null) {
@@ -3666,7 +4055,7 @@ export function createChecker(program, resolver) {
             // if the prop type is an error we don't need to validate again.
             return null;
         }
-        const defaultValue = getValueForNode(defaultNode, ctx.mapper, {
+        const defaultValue = getValueForNode(defaultNode, ctx, {
             kind: "assignment",
             type,
         });
@@ -3792,20 +4181,23 @@ export function createChecker(program, resolver) {
         }
         const resolvedArgs = [];
         function resolveArg(argNode, perParamType) {
-            const arg = getTypeOrValueForNode(argNode, ctx.mapper, {
+            const arg = getTypeOrValueForNode(argNode, ctx, {
                 kind: "argument",
                 constraint: perParamType,
             });
             if (arg !== null &&
                 !(isType(arg) && isErrorType(arg)) &&
                 checkArgumentAssignable(arg, perParamType, argNode)) {
+                const [valid, jsValue] = resolveArgumentJsValue(arg, extractValueOfConstraints({
+                    kind: "argument",
+                    constraint: perParamType,
+                }), argNode);
+                if (!valid)
+                    return undefined;
                 return {
                     value: arg,
                     node: argNode,
-                    jsValue: resolveDecoratorArgJsValue(arg, extractValueOfConstraints({
-                        kind: "argument",
-                        constraint: perParamType,
-                    })),
+                    jsValue,
                 };
             }
             else {
@@ -3873,16 +4265,17 @@ export function createChecker(program, resolver) {
     function getIndexType(type) {
         return type.kind === "Model" ? type.indexer?.value : undefined;
     }
-    function resolveDecoratorArgJsValue(value, valueConstraint) {
+    function resolveArgumentJsValue(value, valueConstraint, diagnosticTarget) {
         if (valueConstraint !== undefined) {
             if (isValue(value)) {
-                return marshallTypeForJS(value, valueConstraint.type);
+                const unmarshaled = marshalTypeForJs(value, valueConstraint.type);
+                return [true, unmarshaled];
             }
             else {
-                return value;
+                return [true, value];
             }
         }
-        return value;
+        return [true, value];
     }
     function checkArgumentAssignable(argumentType, parameterType, diagnosticTarget) {
         const [valid] = relation.isTypeAssignableTo(argumentType, parameterType, diagnosticTarget);
@@ -4184,6 +4577,7 @@ export function createChecker(program, resolver) {
             case "EnumValue":
             case "NullValue":
             case "ScalarValue":
+            case "Function":
                 return value;
         }
     }
@@ -5154,25 +5548,70 @@ function applyDecoratorToType(program, decApp, target) {
         }
     }
 }
-function createDecoratorContext(program, decApp) {
-    function createPassThruContext(program, decApp) {
-        return {
-            program,
-            decoratorTarget: decApp.node,
-            getArgumentTarget: () => decApp.node,
-            call: (decorator, target, ...args) => {
-                return decorator(createPassThruContext(program, decApp), target, ...args);
-            },
-        };
-    }
+function createPassThruContexts(program, target) {
+    const decCtx = {
+        program,
+        decoratorTarget: target,
+        getArgumentTarget: () => target,
+        call: (decorator, target, ...args) => {
+            return decCtx.callDecorator(decorator, target, ...args);
+        },
+        callDecorator(decorator, target, ...args) {
+            return decorator(decCtx, target, ...args);
+        },
+        callFunction(fn, ...args) {
+            return fn(fnCtx, ...args);
+        },
+    };
+    const fnCtx = {
+        program,
+        functionCallTarget: target,
+        getArgumentTarget: () => target,
+        callFunction(fn, ...args) {
+            return fn(fnCtx, ...args);
+        },
+        callDecorator(decorator, target, ...args) {
+            return decorator(decCtx, target, ...args);
+        },
+    };
     return {
+        decorator: decCtx,
+        function: fnCtx,
+    };
+}
+function createDecoratorContext(program, decApp) {
+    const passthrough = createPassThruContexts(program, decApp.node);
+    const decCtx = {
         program,
         decoratorTarget: decApp.node,
         getArgumentTarget: (index) => {
             return decApp.args[index]?.node;
         },
         call: (decorator, target, ...args) => {
-            return decorator(createPassThruContext(program, decApp), target, ...args);
+            return decCtx.callDecorator(decorator, target, ...args);
+        },
+        callDecorator: (decorator, target, ...args) => {
+            return decorator(passthrough.decorator, target, ...args);
+        },
+        callFunction(fn, ...args) {
+            return fn(passthrough.function, ...args);
+        },
+    };
+    return decCtx;
+}
+function createFunctionContext(program, fnCall) {
+    const passthrough = createPassThruContexts(program, fnCall);
+    return {
+        program,
+        functionCallTarget: fnCall,
+        getArgumentTarget: (index) => {
+            return fnCall.arguments[index];
+        },
+        callDecorator(decorator, target, ...args) {
+            return decorator(passthrough.decorator, target, ...args);
+        },
+        callFunction(fn, ...args) {
+            return fn(passthrough.function, ...args);
         },
     };
 }