@typespec/compiler 1.10.0-dev.1 → 1.10.0-dev.10

package/dist/src/core/checker.js

@@ -7,13 +7,15 @@ 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 { getLocationContext } from "./helpers/location-context.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 { checkModifiers } from "./modifiers.js";
 import { Numeric } from "./numeric.js";
 import { exprIsBareIdentifier, getFirstAncestor, getIdentifierContext, hasParseError, visitChildren, } from "./parser.js";
 import { createTypeRelationChecker } from "./type-relation-checker.js";
@@ -175,6 +177,7 @@ export function createChecker(program, resolver) {
         nullType,
         anyType: unknownType,
         voidType,
+        unknownType,
         typePrototype,
         createType,
         createAndFinishType,
@@ -228,6 +231,16 @@ export function createChecker(program, resolver) {
             declarations: [],
             node: undefined, // TODO: is this correct?
         });
+        const internalDecorators = [
+            typespecNamespaceBinding.exports?.get("@indexer"),
+            typespecNamespaceBinding.exports?.get("@docFromComment"),
+            typespecNamespaceBinding.exports?.get("Prototypes")?.exports?.get("@getter"),
+        ];
+        for (const decorator of internalDecorators) {
+            if (decorator) {
+                mutate(decorator).flags |= 8388608 /* SymbolFlags.Internal */;
+            }
+        }
         // Until we have an `unit` type for `null`
         mutate(resolver.symbols.null).type = nullType;
         getSymbolLinks(resolver.symbols.null).type = nullType;
@@ -346,7 +359,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 +373,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 +435,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 +491,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 +521,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 +591,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 +733,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 +749,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 +977,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 +1008,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 +1165,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 +1185,7 @@ export function createChecker(program, resolver) {
         if (cached) {
             return cached;
         }
-        if (instantiateTempalates) {
+        if (instantiateTemplates) {
             return instantiateTemplate(ctx.withMapper(mapper), symbolLinks.instantiations, templateNode, params);
         }
         else {
@@ -1331,12 +1355,10 @@ export function createChecker(program, resolver) {
             // we're not instantiating this operation and we've already checked it
             return links.declaredType;
         }
+        checkModifiers(program, node);
         const namespace = getParentNamespaceType(node);
         compilerAssert(namespace, `Decorator ${node.id.sv} should have resolved a namespace or found the global namespace.`);
         const name = node.id.sv;
-        if (!(node.modifierFlags & 2 /* ModifierFlags.Extern */)) {
-            reportCheckerDiagnostic(createDiagnostic({ code: "decorator-extern", target: node }));
-        }
         const implementation = symbol.value;
         if (implementation === undefined) {
             reportCheckerDiagnostic(createDiagnostic({ code: "missing-implementation", target: node }));
@@ -1355,8 +1377,67 @@ 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;
+        }
+        checkModifiers(program, node);
+        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;
+        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);
@@ -1512,6 +1593,7 @@ export function createChecker(program, resolver) {
             type = initializeTypeForNamespace(node);
         }
         if (node.kind === SyntaxKind.NamespaceStatement) {
+            checkModifiers(program, node);
             if (isArray(node.statements)) {
                 node.statements.forEach((x) => checkNode(ctx, x));
             }
@@ -1619,6 +1701,9 @@ export function createChecker(program, resolver) {
                 return links.declaredType;
             }
         }
+        if (ctx.mapper === undefined) {
+            checkModifiers(program, node);
+        }
         if (ctx.mapper === undefined && inInterface) {
             compilerAssert(parentInterface, "Operation in interface should already have been checked.", node.parent);
         }
@@ -1979,7 +2064,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 +2294,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:
@@ -2239,6 +2327,7 @@ export function createChecker(program, resolver) {
             referenceSymCache.has(node)) {
             return referenceSymCache.get(node);
         }
+        resolvedOptions.locationContext ??= getLocationContext(program, node);
         const sym = resolveTypeReferenceSymInternal(ctx, node, resolvedOptions);
         if (!resolvedOptions.resolveDeclarationOfTemplate) {
             referenceSymCache.set(node, sym);
@@ -2271,8 +2360,9 @@ export function createChecker(program, resolver) {
                     reportAmbiguousIdentifier(node, links.ambiguousSymbols);
                 }
             }
-            const sym = links.resolvedSymbol;
-            return sym?.symbolSource ?? sym;
+            const sym = links.resolvedSymbol?.symbolSource ?? links.resolvedSymbol;
+            checkSymbolAccess(options.locationContext, node, sym);
+            return sym;
         }
         else if (node.kind === SyntaxKind.MemberExpression) {
             let base = resolveTypeReferenceSym(ctx, node.base, {
@@ -2284,22 +2374,42 @@ export function createChecker(program, resolver) {
             }
             // when resolving a type reference based on an alias, unwrap the alias.
             if (base.flags & 128 /* SymbolFlags.Alias */) {
-                const aliasedSym = getAliasedSymbol(ctx, base);
-                if (!aliasedSym) {
-                    reportCheckerDiagnostic(createDiagnostic({
-                        code: "invalid-ref",
-                        messageId: "node",
-                        format: {
-                            id: node.id.sv,
-                            nodeName: base.declarations[0]
-                                ? SyntaxKind[base.declarations[0].kind]
-                                : "Unknown node",
-                        },
-                        target: node,
-                    }));
-                    return undefined;
+                if (!options.resolveDeclarationOfTemplate && isTemplatedNode(getSymNode(base))) {
+                    // This is a bare identifier reference to a templated alias, so we need to actually check this type.
+                    const ty = checkTypeReferenceSymbol(ctx.withMapper(undefined), base, node.base, 
+                    /* instantiateTemplates */ true);
+                    base = lateBindContainer(ty, base);
+                    if (base?.members) {
+                        switch (ty.kind) {
+                            case "Model":
+                            case "Union":
+                            case "Interface":
+                            case "Enum":
+                            case "Scalar":
+                                lateBindMembers(ty);
+                        }
+                    }
+                    if (!base)
+                        return undefined;
+                }
+                else {
+                    const aliasedSym = getAliasedSymbol(ctx, base);
+                    if (!aliasedSym) {
+                        reportCheckerDiagnostic(createDiagnostic({
+                            code: "invalid-ref",
+                            messageId: "node",
+                            format: {
+                                id: node.id.sv,
+                                nodeName: base.declarations[0]
+                                    ? SyntaxKind[base.declarations[0].kind]
+                                    : "Unknown node",
+                            },
+                            target: node,
+                        }));
+                        return undefined;
+                    }
+                    base = aliasedSym;
                 }
-                base = aliasedSym;
             }
             else if (!options.resolveDeclarationOfTemplate && isTemplatedNode(getSymNode(base))) {
                 const baseSym = getContainerTemplateSymbol(ctx, base, node.base);
@@ -2308,10 +2418,47 @@ export function createChecker(program, resolver) {
                 }
                 base = baseSym;
             }
-            return resolveMemberInContainer(base, node, options);
+            const sym = resolveMemberInContainer(base, node, options);
+            checkSymbolAccess(options.locationContext, node, sym);
+            return sym;
         }
         compilerAssert(false, `Unknown type reference kind "${SyntaxKind[node.kind]}"`, node);
     }
+    function checkSymbolAccess(sourceLocation, node, symbol) {
+        if (!symbol)
+            return;
+        const isInternalDeclaration = (symbol.flags & (8388608 /* SymbolFlags.Internal */ | 1048576 /* SymbolFlags.Declaration */)) ===
+            (8388608 /* SymbolFlags.Internal */ | 1048576 /* SymbolFlags.Declaration */);
+        if (isInternalDeclaration) {
+            // The source location can access internal declaration symbols if:
+            // 1. The source location is synthetic.
+            // 2. The source location is in the compiler standard library.
+            // 3. SOME declaration of the target symbol meets the following:
+            //   1. The source location is in the user project, and the symbol is also declared in the user project.
+            //   2. The source location is in a library, and the symbol is also in the same library.
+            if (sourceLocation.type === "synthetic" || sourceLocation.type === "compiler") {
+                return;
+            }
+            const isDeclaredInCompatibleLocation = symbol.declarations.some((decl) => {
+                const declLocation = getLocationContext(program, decl);
+                if (declLocation.type !== sourceLocation.type)
+                    return false;
+                // Both are project
+                if (declLocation.type === "project")
+                    return true;
+                // Both are library, use reference equality to check if they are the same library.
+                return declLocation === sourceLocation;
+            });
+            if (isDeclaredInCompatibleLocation)
+                return;
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "invalid-ref",
+                messageId: "internal",
+                format: { id: symbol.name },
+                target: node,
+            }));
+        }
+    }
     function reportAmbiguousIdentifier(node, symbols) {
         const duplicateNames = symbols.map((s) => getFullyQualifiedSymbolName(s, { useGlobalPrefixAtTopLevel: true }));
         program.reportDiagnostic(createDiagnostic({
@@ -2699,6 +2846,9 @@ export function createChecker(program, resolver) {
             // we're not instantiating this model and we've already checked it
             return links.declaredType;
         }
+        if (ctx.mapper === undefined) {
+            checkModifiers(program, node);
+        }
         checkTemplateDeclaration(ctx, node);
         const decorators = [];
         const type = createType({
@@ -3109,17 +3259,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. */
@@ -3244,9 +3445,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");
         }
@@ -3265,6 +3470,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) {
@@ -3646,7 +4109,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,
         });
@@ -3772,20 +4235,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 {
@@ -3853,16 +4319,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);
@@ -3986,6 +4453,9 @@ export function createChecker(program, resolver) {
             // we're not instantiating this model and we've already checked it
             return links.declaredType;
         }
+        if (ctx.mapper === undefined) {
+            checkModifiers(program, node);
+        }
         checkTemplateDeclaration(ctx, node);
         const decorators = [];
         const type = createType({
@@ -4097,6 +4567,9 @@ export function createChecker(program, resolver) {
         if (links.declaredType && ctx.mapper === undefined) {
             return links.declaredType;
         }
+        if (ctx.mapper === undefined) {
+            checkModifiers(program, node);
+        }
         checkTemplateDeclaration(ctx, node);
         const aliasSymId = getNodeSym(node);
         if (pendingResolutions.has(aliasSymId, ResolutionKind.Type)) {
@@ -4130,6 +4603,7 @@ export function createChecker(program, resolver) {
         if (links.value !== undefined) {
             return links.value;
         }
+        checkModifiers(program, node);
         const type = node.type ? getTypeForNode(node.type, undefined) : undefined;
         if (pendingResolutions.has(node.symbol, ResolutionKind.Value)) {
             reportCheckerDiagnostic(createDiagnostic({
@@ -4164,12 +4638,14 @@ export function createChecker(program, resolver) {
             case "EnumValue":
             case "NullValue":
             case "ScalarValue":
+            case "Function":
                 return value;
         }
     }
     function checkEnum(ctx, node) {
         const links = getSymbolLinks(node.symbol);
         if (!links.type) {
+            checkModifiers(program, node);
             const enumType = (links.type = createType({
                 kind: "Enum",
                 name: node.id.sv,
@@ -4219,6 +4695,9 @@ export function createChecker(program, resolver) {
             // we're not instantiating this interface and we've already checked it
             return links.declaredType;
         }
+        if (ctx.mapper === undefined) {
+            checkModifiers(program, node);
+        }
         checkTemplateDeclaration(ctx, node);
         const interfaceType = createType({
             kind: "Interface",
@@ -4305,6 +4784,9 @@ export function createChecker(program, resolver) {
             // we're not instantiating this union and we've already checked it
             return links.declaredType;
         }
+        if (ctx.mapper === undefined) {
+            checkModifiers(program, node);
+        }
         checkTemplateDeclaration(ctx, node);
         const variants = createRekeyableMap();
         const unionType = createType({
@@ -5134,25 +5616,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);
         },
     };
 }