@typespec/compiler 0.57.0-dev.0 → 0.57.0-dev.4

package/dist/src/core/checker.js

@@ -1,17 +1,22 @@
-import { $docFromComment, isArrayModelType } from "../lib/decorators.js";
-import { getIndexer } from "../lib/intrinsic-decorators.js";
+import { $docFromComment, getIndexer } from "../lib/intrinsic-decorators.js";
 import { MultiKeyMap, createRekeyableMap, isArray, mutate } from "../utils/misc.js";
 import { createSymbol, createSymbolTable } from "./binder.js";
 import { createChangeIdentifierCodeFix } from "./compiler-code-fixes/change-identifier.codefix.js";
+import { createModelToObjectValueCodeFix } from "./compiler-code-fixes/model-to-object-literal.codefix.js";
+import { createTupleToArrayValueCodeFix } from "./compiler-code-fixes/tuple-to-array-value.codefix.js";
 import { getDeprecationDetails, markDeprecated } from "./deprecation.js";
-import { ProjectionError, compilerAssert, reportDeprecated } from "./diagnostics.js";
+import { ProjectionError, compilerAssert, ignoreDiagnostics, reportDeprecated, } from "./diagnostics.js";
 import { validateInheritanceDiscriminatedUnions } from "./helpers/discriminator-utils.js";
-import { getNamespaceFullName, getTypeName, stringTemplateToString, } from "./helpers/index.js";
-import { isStringTemplateSerializable } from "./helpers/string-template-utils.js";
+import { getEntityName, getLocationContext, getNamespaceFullName, getTypeName, } from "./helpers/index.js";
+import { explainStringTemplateNotSerializable } from "./helpers/string-template-utils.js";
+import { getMaxItems, getMaxLength, getMaxValueAsNumeric, getMaxValueExclusiveAsNumeric, getMinItems, getMinLength, getMinValueAsNumeric, getMinValueExclusiveAsNumeric, } from "./intrinsic-type-state.js";
+import { canNumericConstraintBeJsNumber, legacyMarshallTypeForJS, marshallTypeForJS, } from "./js-marshaller.js";
 import { createDiagnostic } from "./messages.js";
+import { numericRanges } from "./numeric-ranges.js";
+import { Numeric } from "./numeric.js";
 import { exprIsBareIdentifier, getIdentifierContext, hasParseError, visitChildren, } from "./parser.js";
 import { createProjectionMembers } from "./projection-members.js";
-import { getFullyQualifiedSymbolName, getParentTemplateNode, isNeverType, isTemplateInstance, isUnknownType, isVoidType, } from "./type-utils.js";
+import { getFullyQualifiedSymbolName, getParentTemplateNode, isArrayModelType, isErrorType, isNeverType, isNullType, isTemplateInstance, isType, isUnknownType, isValue, isVoidType, } from "./type-utils.js";
 import { IdentifierKind, SyntaxKind, } from "./types.js";
 /**
  * Maps type arguments to type instantiation.
@@ -105,6 +110,7 @@ export function createChecker(program) {
         project,
         neverType,
         errorType,
+        nullType,
         anyType: unknownType,
         voidType,
         typePrototype,
@@ -117,6 +123,8 @@ export function createChecker(program) {
         isStdType,
         getStdType,
         resolveTypeReference,
+        getValueForNode,
+        getTypeOrValueForNode,
     };
     const projectionMembers = createProjectionMembers(checker);
     return checker;
@@ -207,13 +215,13 @@ export function createChecker(program) {
                 if (ref.flags & 4096 /* SymbolFlags.Namespace */) {
                     const links = getSymbolLinks(getMergedSymbol(ref));
                     const type = links.type;
-                    const decApp = checkDecorator(type, decNode, undefined);
+                    const decApp = checkDecoratorApplication(type, decNode, undefined);
                     if (decApp) {
                         type.decorators.push(decApp);
                         applyDecoratorToType(program, decApp, type);
                     }
                 }
-                else if (args.length > 0 || ref.flags & 16777216 /* SymbolFlags.LateBound */) {
+                else if (args.length > 0 || ref.flags & 67108864 /* SymbolFlags.LateBound */) {
                     reportCheckerDiagnostic(createDiagnostic({
                         code: "augment-decorator-target",
                         messageId: "noInstance",
@@ -313,9 +321,259 @@ export function createChecker(program) {
                 return checkOperation(node, mapper, containerType);
             case SyntaxKind.UnionVariant:
                 return checkUnionVariant(node, mapper);
+            case SyntaxKind.ScalarConstructor:
+                return checkScalarConstructor(node, mapper, containerType);
         }
     }
     function getTypeForNode(node, mapper) {
+        const entity = checkNode(node, mapper);
+        if (entity === null) {
+            return errorType;
+        }
+        if (entity.entityKind === "Indeterminate") {
+            return entity.type;
+        }
+        if (isValue(entity)) {
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "value-in-type",
+                target: node,
+            }));
+            return errorType;
+        }
+        if (entity.kind === "TemplateParameter") {
+            if (entity.constraint?.valueType) {
+                // means this template constraint will accept values
+                reportCheckerDiagnostic(createDiagnostic({
+                    code: "value-in-type",
+                    messageId: "referenceTemplate",
+                    target: node,
+                }));
+            }
+        }
+        return entity;
+    }
+    function getValueForNode(node, mapper, constraint, options = {}) {
+        const initial = checkNode(node, mapper, constraint);
+        if (initial === null) {
+            return null;
+        }
+        let entity;
+        if (initial.entityKind === "Indeterminate") {
+            entity = getValueFromIndeterminate(initial.type, constraint, node);
+        }
+        else {
+            entity = initial;
+        }
+        if (options.legacyTupleAndModelCast && entity !== null && isType(entity)) {
+            entity = legacy_tryTypeToValueCast(entity, constraint, node);
+        }
+        if (entity === null) {
+            return null;
+        }
+        if (isValue(entity)) {
+            return constraint ? inferScalarsFromConstraints(entity, constraint.type) : entity;
+        }
+        reportExpectedValue(node, entity);
+        return null;
+    }
+    function reportExpectedValue(target, type) {
+        if (type.kind === "Model" && type.name === "" && target.kind === SyntaxKind.ModelExpression) {
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "expect-value",
+                messageId: "model",
+                format: { name: getTypeName(type) },
+                codefixes: [createModelToObjectValueCodeFix(target)],
+                target,
+            }));
+        }
+        else if (type.kind === "Tuple" && target.kind === SyntaxKind.TupleExpression) {
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "expect-value",
+                messageId: "tuple",
+                format: { name: getTypeName(type) },
+                codefixes: [createTupleToArrayValueCodeFix(target)],
+                target,
+            }));
+        }
+        else {
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "expect-value",
+                format: { name: getTypeName(type) },
+                target,
+            }));
+        }
+    }
+    /** In certain context for types that can also be value if the constraint allows it we try to use it as a value instead of a type. */
+    function getValueFromIndeterminate(type, constraint, node) {
+        switch (type.kind) {
+            case "String":
+            case "StringTemplate":
+                return checkStringValue(type, constraint, node);
+            case "Number":
+                return checkNumericValue(type, constraint, node);
+            case "Boolean":
+                return checkBooleanValue(type, constraint, node);
+            case "EnumMember":
+                return checkEnumValue(type, constraint, node);
+            case "UnionVariant":
+                return getValueFromIndeterminate(type.type, constraint, node);
+            case "Intrinsic":
+                switch (type.name) {
+                    case "null":
+                        return checkNullValue(type, constraint, node);
+                }
+                return type;
+            default:
+                return type;
+        }
+    }
+    function legacy_tryTypeToValueCast(type, constraint, node) {
+        switch (type.kind) {
+            case "Tuple":
+                return legacy_tryUsingTupleAsArrayValue(type, constraint?.type, node);
+            case "Model":
+                return legacy_tryUsingModelAsObjectValue(type, constraint?.type, node);
+            default:
+                return type;
+        }
+    }
+    // Legacy behavior to smooth transition to object values.
+    function legacy_tryUsingModelAsObjectValue(model, type, node) {
+        if (model.node?.kind !== SyntaxKind.ModelExpression) {
+            return model; // we only want to convert model expressions
+        }
+        reportCheckerDiagnostic(createDiagnostic({
+            code: "deprecated",
+            codefixes: [createModelToObjectValueCodeFix(model.node)],
+            format: {
+                message: "Using a model as a value is deprecated. Use an object value instead(with #{}).",
+            },
+            target: model.node,
+        }));
+        const value = {
+            entityKind: "Value",
+            valueKind: "ObjectValue",
+            type: type ?? model,
+            node: model.node,
+            properties: new Map(),
+        };
+        for (const prop of model.properties.values()) {
+            let propValue = getValueFromIndeterminate(prop.type, { kind: "assignment", type: prop.type }, node);
+            if (propValue !== null && isType(propValue)) {
+                propValue = legacy_tryTypeToValueCast(propValue, { kind: "assignment", type: prop.type }, node);
+            }
+            if (propValue == null) {
+                return null;
+            }
+            else if (!isValue(propValue)) {
+                return model;
+            }
+            value.properties.set(prop.name, {
+                name: prop.name,
+                value: propValue,
+                node: prop.node,
+            });
+        }
+        if (type !== undefined && !checkTypeAssignable(model, type, node)) {
+            return null;
+        }
+        return value;
+    }
+    // Legacy behavior to smooth transition to array values.
+    function legacy_tryUsingTupleAsArrayValue(tuple, type, node) {
+        if (tuple.node.kind !== SyntaxKind.TupleExpression) {
+            return tuple; // we won't convert dynamic tuples to array values
+        }
+        reportCheckerDiagnostic(createDiagnostic({
+            code: "deprecated",
+            codefixes: [createTupleToArrayValueCodeFix(tuple.node)],
+            format: {
+                message: "Using a tuple as a value is deprecated. Use an array value instead(with #[]).",
+            },
+            target: tuple.node,
+        }));
+        const values = [];
+        for (const [index, item] of tuple.values.entries()) {
+            const itemType = type?.kind === "Model" && isArrayModelType(program, type)
+                ? type.indexer.value
+                : type?.kind === "Tuple"
+                    ? type.values[index]
+                    : undefined;
+            let value = getValueFromIndeterminate(item, itemType && { kind: "assignment", type: itemType }, node);
+            if (value !== null && isType(value)) {
+                value = legacy_tryTypeToValueCast(value, itemType && { kind: "assignment", type: itemType }, node);
+            }
+            if (value === null) {
+                return null;
+            }
+            else if (!isValue(value)) {
+                return tuple;
+            }
+            values.push(value);
+        }
+        if (type !== undefined && !checkTypeAssignable(tuple, type, node)) {
+            return null;
+        }
+        return {
+            entityKind: "Value",
+            valueKind: "ArrayValue",
+            type: type ?? tuple,
+            node: tuple.node,
+            values,
+        };
+    }
+    /**
+     * Gets a type or value depending on the node and current constraint.
+     * 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 valueConstraint = extractValueOfConstraints(constraint);
+        const entity = checkNode(node, mapper, valueConstraint);
+        if (entity === null) {
+            return entity;
+        }
+        else if (isType(entity)) {
+            if (valueConstraint) {
+                return legacy_tryTypeToValueCast(entity, valueConstraint, node);
+            }
+            else {
+                return entity;
+            }
+        }
+        else if (isValue(entity)) {
+            return entity;
+        }
+        compilerAssert(entity.entityKind === "Indeterminate", "Expected indeterminate entity");
+        if (valueConstraint) {
+            const valueDiagnostics = [];
+            const oldDiagnosticHook = onCheckerDiagnostic;
+            onCheckerDiagnostic = (x) => valueDiagnostics.push(x);
+            const result = getValueFromIndeterminate(entity.type, valueConstraint, node);
+            onCheckerDiagnostic = oldDiagnosticHook;
+            if (result) {
+                // If there were diagnostic reported but we still got a value this means that the value might be invalid.
+                reportCheckerDiagnostics(valueDiagnostics);
+                return result;
+            }
+        }
+        return entity.type;
+    }
+    /** Extact the type constraint a value should match. */
+    function extractValueOfConstraints(constraint) {
+        if (constraint?.constraint.valueType) {
+            return { kind: constraint.kind, type: constraint.constraint.valueType };
+        }
+        else {
+            return undefined;
+        }
+    }
+    /**
+     * Gets a type, value or indeterminate depending on the node and current constraint.
+     * For nodes that can be both type or values(e.g. string literals), an indeterminate entity will be returned.
+     * It is the job of of the consumer to decide if it should be a type or a value depending on the context.
+     */
+    function checkNode(node, mapper, valueConstraint) {
         switch (node.kind) {
             case SyntaxKind.ModelExpression:
                 return checkModel(node, mapper);
@@ -346,10 +604,10 @@ export function createChecker(program) {
                 return checkNumericLiteral(node);
             case SyntaxKind.BooleanLiteral:
                 return checkBooleanLiteral(node);
-            case SyntaxKind.TupleExpression:
-                return checkTupleExpression(node, mapper);
             case SyntaxKind.StringLiteral:
                 return checkStringLiteral(node);
+            case SyntaxKind.TupleExpression:
+                return checkTupleExpression(node, mapper);
             case SyntaxKind.StringTemplateExpression:
                 return checkStringTemplateExpresion(node, mapper);
             case SyntaxKind.ArrayExpression:
@@ -363,7 +621,7 @@ export function createChecker(program) {
             case SyntaxKind.FunctionDeclarationStatement:
                 return checkFunctionDeclaration(node, mapper);
             case SyntaxKind.TypeReference:
-                return checkTypeReference(node, mapper);
+                return checkTypeOrValueReference(node, mapper);
             case SyntaxKind.TemplateArgument:
                 return checkTemplateArgument(node, mapper);
             case SyntaxKind.TemplateParameterDeclaration:
@@ -376,12 +634,19 @@ export function createChecker(program) {
                 return neverType;
             case SyntaxKind.UnknownKeyword:
                 return unknownType;
+            case SyntaxKind.ObjectLiteral:
+                return checkObjectValue(node, mapper, valueConstraint);
+            case SyntaxKind.ArrayLiteral:
+                return checkArrayValue(node, mapper, valueConstraint);
+            case SyntaxKind.ConstStatement:
+                return checkConst(node);
+            case SyntaxKind.CallExpression:
+                return checkCallExpression(node, mapper);
+            case SyntaxKind.TypeOfExpression:
+                return checkTypeOfExpression(node, mapper);
+            default:
+                return errorType;
         }
-        // we don't emit an error here as we blindly call this function
-        // with any node type, but some nodes don't produce a type
-        // (e.g. imports). errorType should result in an error if it
-        // bubbles out somewhere its not supposed to be.
-        return errorType;
     }
     /**
      * Return a fully qualified id of node
@@ -440,7 +705,7 @@ export function createChecker(program) {
             });
             if (node.constraint) {
                 pendingResolutions.start(getNodeSymId(node), ResolutionKind.Constraint);
-                type.constraint = getTypeOrValueTypeForNode(node.constraint);
+                type.constraint = getParamConstraintEntityForNode(node.constraint);
                 pendingResolutions.finish(getNodeSymId(node), ResolutionKind.Constraint);
             }
             if (node.default) {
@@ -453,23 +718,24 @@ export function createChecker(program) {
         if (declaredType.default === undefined) {
             return undefined;
         }
-        if (isErrorType(declaredType.default)) {
+        if ((isType(declaredType.default) && isErrorType(declaredType.default)) ||
+            declaredType.default === null) {
             return declaredType.default;
         }
-        return getTypeForNode(node.default, mapper);
+        return checkNode(node.default, mapper);
     }
     function checkTemplateParameterDefault(nodeDefault, templateParameters, index, constraint) {
         function visit(node) {
-            const type = getTypeForNode(node);
+            const entity = checkNode(node);
             let hasError = false;
-            if (type.kind === "TemplateParameter") {
+            if (entity !== null && "kind" in entity && entity.kind === "TemplateParameter") {
                 for (let i = index; i < templateParameters.length; i++) {
-                    if (type.node.symbol === templateParameters[i].symbol) {
+                    if (entity.node.symbol === templateParameters[i].symbol) {
                         reportCheckerDiagnostic(createDiagnostic({ code: "invalid-template-default", target: node }));
                         return undefined;
                     }
                 }
-                return type;
+                return entity;
             }
             visitChildren(node, (x) => {
                 const visited = visit(x);
@@ -477,10 +743,10 @@ export function createChecker(program) {
                     hasError = true;
                 }
             });
-            return hasError ? undefined : type;
+            return hasError ? undefined : entity;
         }
         const type = visit(nodeDefault) ?? errorType;
-        if (!isErrorType(type) && constraint) {
+        if (!("kind" in type && isErrorType(type)) && constraint) {
             checkTypeAssignable(type, constraint, nodeDefault);
         }
         return type;
@@ -500,8 +766,22 @@ export function createChecker(program) {
         const type = checkTypeReferenceSymbol(sym, node, mapper, instantiateTemplate);
         return type;
     }
+    /**
+     * Check and resolve a type for the given type reference node.
+     * @param node Node.
+     * @param mapper Type mapper for template instantiation context.
+     * @param instantiateTemplate If templated type should be instantiated if they haven't yet.
+     * @returns Resolved type.
+     */
+    function checkTypeOrValueReference(node, mapper, instantiateTemplate = true) {
+        const sym = resolveTypeReferenceSym(node, mapper);
+        if (!sym) {
+            return errorType;
+        }
+        return checkTypeOrValueReferenceSymbol(sym, node, mapper, instantiateTemplate) ?? errorType;
+    }
     function checkTemplateArgument(node, mapper) {
-        return getTypeForNode(node.argument, mapper);
+        return checkNode(node.argument, mapper);
     }
     function resolveTypeReference(node) {
         const oldDiagnosticHook = onCheckerDiagnostic;
@@ -567,8 +847,8 @@ export function createChecker(program) {
     function checkTemplateInstantiationArgs(node, args, decls, mapper) {
         const params = new Map();
         const positional = [];
-        const initMap = new Map(decls.map(function (decl) {
-            const declaredType = getTypeForNode(decl);
+        const initMap = new Map(decls.map((decl) => {
+            const declaredType = checkTemplateParameterDeclaration(decl, undefined);
             positional.push(declaredType);
             params.set(decl.id.sv, declaredType);
             return [
@@ -582,7 +862,7 @@ export function createChecker(program) {
         let named = false;
         for (const [arg, idx] of args.map((v, i) => [v, i])) {
             function deferredCheck() {
-                return [arg, getTypeForNode(arg.argument, mapper)];
+                return [arg, checkNode(arg.argument, mapper)];
             }
             if (arg.name) {
                 named = true;
@@ -657,18 +937,30 @@ export function createChecker(program) {
                         target: node,
                     }));
                     // TODO-TIM check if we expose this below
-                    commit(param, param.constraint?.kind === "Value" ? unknownType : param.constraint ?? unknownType);
+                    commit(param, param.constraint?.type ?? unknownType);
                 }
                 continue;
             }
             const [argNode, type] = init();
+            if (type === null) {
+                commit(param, unknownType);
+                continue;
+            }
             if (param.constraint) {
-                const constraint = param.constraint.kind === "TemplateParameter"
-                    ? finalMap.get(param.constraint)
+                const constraint = param.constraint.type?.kind === "TemplateParameter"
+                    ? finalMap.get(param.constraint.type)
                     : param.constraint;
-                if (!checkTypeAssignable(type, constraint, argNode)) {
-                    // TODO-TIM check if we expose this below
-                    const effectiveType = param.constraint?.kind === "Value" ? unknownType : param.constraint;
+                if (isType(type) && param.constraint?.valueType) {
+                    const converted = legacy_tryTypeToValueCast(type, { kind: "argument", type: param.constraint.valueType }, argNode);
+                    // If we manage to convert it means this might be convertable so we skip type checking.
+                    // However we still return the original entity
+                    if (converted !== type) {
+                        commit(param, type);
+                        continue;
+                    }
+                }
+                if (param.constraint && !checkArgumentAssignable(type, constraint, argNode)) {
+                    const effectiveType = param.constraint.type ?? unknownType;
                     commit(param, effectiveType);
                     continue;
                 }
@@ -679,6 +971,15 @@ export function createChecker(program) {
                 commit(param, unknownType);
                 continue;
             }
+            else if (isValue(type)) {
+                reportCheckerDiagnostic(createDiagnostic({
+                    code: "value-in-type",
+                    messageId: "noTemplateConstraint",
+                    target: argNode,
+                }));
+                commit(param, unknownType);
+                continue;
+            }
             commit(param, type);
         }
         return finalMap;
@@ -692,6 +993,20 @@ export function createChecker(program) {
      * @returns resolved type.
      */
     function checkTypeReferenceSymbol(sym, node, mapper, instantiateTemplates = true) {
+        const result = checkTypeOrValueReferenceSymbol(sym, node, mapper, instantiateTemplates);
+        if (result === null || isValue(result)) {
+            reportCheckerDiagnostic(createDiagnostic({ code: "value-in-type", target: node }));
+            return errorType;
+        }
+        if (result.entityKind === "Indeterminate") {
+            return result.type;
+        }
+        return result;
+    }
+    function checkTypeOrValueReferenceSymbol(sym, node, mapper, instantiateTemplates = true) {
+        if (sym.flags & 16777216 /* SymbolFlags.Const */) {
+            return getValueForNode(sym.declarations[0], mapper);
+        }
         if (sym.flags & 16384 /* SymbolFlags.Decorator */) {
             reportCheckerDiagnostic(createDiagnostic({ code: "invalid-type-ref", messageId: "decorator", target: sym }));
             return errorType;
@@ -719,14 +1034,14 @@ export function createChecker(program) {
                         target: node,
                     }));
                 }
-                if (sym.flags & 16777216 /* SymbolFlags.LateBound */) {
+                if (sym.flags & 67108864 /* SymbolFlags.LateBound */) {
                     compilerAssert(sym.type, "Expected late bound symbol to have type");
                     return sym.type;
                 }
                 else if (symbolLinks.declaredType) {
                     baseType = symbolLinks.declaredType;
                 }
-                else if (sym.flags & 1348 /* SymbolFlags.Member */) {
+                else if (sym.flags & 33555780 /* SymbolFlags.Member */) {
                     baseType = checkMemberSym(sym, mapper);
                 }
                 else {
@@ -749,12 +1064,13 @@ export function createChecker(program) {
                     target: node,
                 }));
             }
-            if (sym.flags & 16777216 /* SymbolFlags.LateBound */) {
-                compilerAssert(sym.type, "Expected late bound symbol to have type");
+            if (sym.flags & 67108864 /* SymbolFlags.LateBound */) {
+                compilerAssert(sym.type, `Expected late bound symbol to have type`);
                 return sym.type;
             }
             else if (sym.flags & 32768 /* SymbolFlags.TemplateParameter */) {
-                baseType = checkTemplateParameterDeclaration(sym.declarations[0], mapper);
+                const mapped = checkTemplateParameterDeclaration(sym.declarations[0], mapper);
+                baseType = mapped;
             }
             else if (symbolLinks.type) {
                 // Have a cached type for non-declarations
@@ -764,7 +1080,7 @@ export function createChecker(program) {
                 baseType = symbolLinks.declaredType;
             }
             else {
-                if (sym.flags & 1348 /* SymbolFlags.Member */) {
+                if (sym.flags & 33555780 /* SymbolFlags.Member */) {
                     baseType = checkMemberSym(sym, mapper);
                 }
                 else {
@@ -783,6 +1099,12 @@ export function createChecker(program) {
                 checkDeprecated(baseType, declarationNode, node);
             }
         }
+        // Elements that could be used as type or values depending on the context
+        if (baseType.kind === "EnumMember" ||
+            baseType.kind === "UnionVariant" ||
+            isNullType(baseType)) {
+            return createIndeterminateEntity(baseType);
+        }
         return baseType;
     }
     /**
@@ -797,11 +1119,11 @@ export function createChecker(program) {
         if (symbolLinks.declaredType) {
             return symbolLinks.declaredType;
         }
-        if (sym.flags & 16777216 /* SymbolFlags.LateBound */) {
+        if (sym.flags & 67108864 /* SymbolFlags.LateBound */) {
             compilerAssert(sym.type, "Expected late bound symbol to have type");
             return sym.type;
         }
-        if (sym.flags & 1348 /* SymbolFlags.Member */) {
+        if (sym.flags & 33555780 /* SymbolFlags.Member */) {
             return checkMemberSym(sym, mapper);
         }
         else {
@@ -816,7 +1138,7 @@ export function createChecker(program) {
      * @returns The declared type for the given node.
      */
     function checkDeclaredType(sym, node, mapper) {
-        return sym.flags & 2 /* SymbolFlags.Model */
+        const type = sym.flags & 2 /* SymbolFlags.Model */
             ? checkModelStatement(node, mapper)
             : sym.flags & 8 /* SymbolFlags.Scalar */
                 ? checkScalar(node, mapper)
@@ -827,6 +1149,7 @@ export function createChecker(program) {
                         : sym.flags & 16 /* SymbolFlags.Operation */
                             ? checkOperation(node, mapper)
                             : checkUnion(node, mapper);
+        return type;
     }
     function getOrInstantiateTemplate(templateNode, params, args, parentMapper, instantiateTempalates = true) {
         const symbolLinks = templateNode.kind === SyntaxKind.OperationStatement &&
@@ -874,6 +1197,57 @@ export function createChecker(program) {
         }
         return type;
     }
+    /** Check a union expresion used in a parameter constraint, those allow the use of `valueof` as a variant. */
+    function checkMixedParameterConstraintUnion(node, mapper) {
+        const values = [];
+        const types = [];
+        for (const option of node.options) {
+            const [kind, type] = getTypeOrValueOfTypeForNode(option, mapper);
+            if (kind === "value") {
+                values.push(type);
+            }
+            else {
+                types.push(type);
+            }
+        }
+        return {
+            entityKind: "MixedParameterConstraint",
+            node,
+            valueType: values.length === 0
+                ? undefined
+                : values.length === 1
+                    ? values[0]
+                    : createConstraintUnion(node, values),
+            type: types.length === 0
+                ? undefined
+                : types.length === 1
+                    ? types[0]
+                    : createConstraintUnion(node, types),
+        };
+    }
+    function createConstraintUnion(node, options) {
+        const variants = createRekeyableMap();
+        const union = createAndFinishType({
+            kind: "Union",
+            node,
+            options,
+            decorators: [],
+            variants,
+            expression: true,
+        });
+        for (const option of options) {
+            const name = Symbol("indexer-union-variant");
+            variants.set(name, createAndFinishType({
+                kind: "UnionVariant",
+                node: undefined,
+                type: option,
+                name,
+                union,
+                decorators: [],
+            }));
+        }
+        return union;
+    }
     function checkUnionExpression(node, mapper) {
         const unionType = createAndFinishType({
             kind: "Union",
@@ -910,13 +1284,6 @@ export function createChecker(program) {
         }
         return unionType;
     }
-    function checkValueOfExpression(node, mapper) {
-        const target = getTypeForNode(node.target, mapper);
-        return {
-            kind: "Value",
-            target,
-        };
-    }
     /**
      * Intersection produces a model type from the properties of its operands.
      * So this doesn't work if we don't have a known set of properties (e.g.
@@ -948,14 +1315,43 @@ export function createChecker(program) {
             name: `@${name}`,
             namespace,
             node,
-            target: checkFunctionParameter(node.target, mapper),
-            parameters: node.parameters.map((x) => checkFunctionParameter(x, mapper)),
+            target: checkFunctionParameter(node.target, mapper, true),
+            parameters: node.parameters.map((x) => checkFunctionParameter(x, mapper, true)),
             implementation: implementation ?? (() => { }),
         });
         namespace.decoratorDeclarations.set(name, decoratorType);
         linkType(links, decoratorType, mapper);
+        checkDecoratorLegacyMarshalling(decoratorType);
         return decoratorType;
     }
+    function checkDecoratorLegacyMarshalling(decorator) {
+        const marshalling = resolveDecoratorArgMarshalling(decorator);
+        function reportDeprecatedLegacyMarshalling(param, message) {
+            reportDeprecated(program, [
+                `Parameter ${param.name} of decorator ${decorator.name} is using legacy marshalling but is accepting ${message}.`,
+                `This will change in the future.`,
+                'Add `export const $flags = {decoratorArgMarshalling: "new"}}` to your library to opt-in to the new marshalling behavior.',
+            ].join("\n"), param.node);
+        }
+        if (marshalling === "legacy") {
+            for (const param of decorator.parameters) {
+                if (param.type.valueType) {
+                    if (ignoreDiagnostics(isTypeAssignableTo(nullType, param.type.valueType, param.type))) {
+                        reportDeprecatedLegacyMarshalling(param, "null as a type");
+                    }
+                    else if (param.type.valueType.kind === "Enum" ||
+                        param.type.valueType.kind === "EnumMember" ||
+                        (isReflectionType(param.type.valueType) && param.type.valueType.name === "EnumMember")) {
+                        reportDeprecatedLegacyMarshalling(param, "enum members");
+                    }
+                    else if (ignoreDiagnostics(isTypeAssignableTo(param.type.valueType, getStdType("numeric"), param.type.valueType)) &&
+                        !canNumericConstraintBeJsNumber(param.type.valueType)) {
+                        reportDeprecatedLegacyMarshalling(param, "a numeric type that is not representable as a JS Number");
+                    }
+                }
+            }
+        }
+    }
     function checkFunctionDeclaration(node, mapper) {
         const symbol = getMergedSymbol(node.symbol);
         const links = getSymbolLinks(symbol);
@@ -978,7 +1374,7 @@ export function createChecker(program) {
             name,
             namespace,
             node,
-            parameters: node.parameters.map((x) => checkFunctionParameter(x, mapper)),
+            parameters: node.parameters.map((x) => checkFunctionParameter(x, mapper, true)),
             returnType: node.returnType ? getTypeForNode(node.returnType, mapper) : unknownType,
             implementation: implementation ?? (() => { }),
         });
@@ -986,7 +1382,7 @@ export function createChecker(program) {
         linkType(links, functionType, mapper);
         return functionType;
     }
-    function checkFunctionParameter(node, mapper) {
+    function checkFunctionParameter(node, mapper, mixed) {
         const links = getSymbolLinks(node.symbol);
         if (links.declaredType) {
             return links.declaredType;
@@ -998,24 +1394,62 @@ export function createChecker(program) {
                     node.type.target.kind === SyntaxKind.ArrayExpression))) {
             reportCheckerDiagnostic(createDiagnostic({ code: "rest-parameter-array", target: node.type }));
         }
-        const type = node.type ? getTypeOrValueTypeForNode(node.type) : unknownType;
-        const parameterType = createType({
+        const base = {
             kind: "FunctionParameter",
             node,
             name: node.id.sv,
             optional: node.optional,
             rest: node.rest,
-            type,
             implementation: node.symbol.value,
-        });
+        };
+        let parameterType;
+        if (mixed) {
+            const type = node.type
+                ? getParamConstraintEntityForNode(node.type)
+                : ({
+                    entityKind: "MixedParameterConstraint",
+                    type: unknownType,
+                });
+            parameterType = createType({
+                ...base,
+                type,
+                mixed: true,
+                implementation: node.symbol.value,
+            });
+        }
+        else {
+            parameterType = createType({
+                ...base,
+                mixed: false,
+                type: node.type ? getTypeForNode(node.type) : unknownType,
+                implementation: node.symbol.value,
+            });
+        }
         linkType(links, parameterType, mapper);
         return parameterType;
     }
-    function getTypeOrValueTypeForNode(node, mapper) {
-        if (node.kind === SyntaxKind.ValueOfExpression) {
-            return checkValueOfExpression(node, mapper);
+    function getTypeOrValueOfTypeForNode(node, mapper) {
+        switch (node.kind) {
+            case SyntaxKind.ValueOfExpression:
+                const target = getTypeForNode(node.target, mapper);
+                return ["value", target];
+            default:
+                return ["type", getTypeForNode(node, mapper)];
+        }
+    }
+    function getParamConstraintEntityForNode(node, mapper) {
+        switch (node.kind) {
+            case SyntaxKind.UnionExpression:
+                return checkMixedParameterConstraintUnion(node, mapper);
+            default:
+                const [kind, entity] = getTypeOrValueOfTypeForNode(node, mapper);
+                return {
+                    entityKind: "MixedParameterConstraint",
+                    node: node,
+                    type: kind === "value" ? undefined : entity,
+                    valueType: kind === "value" ? entity : undefined,
+                };
         }
-        return getTypeForNode(node, mapper);
     }
     function mergeModelTypes(node, options, mapper) {
         const properties = createRekeyableMap();
@@ -1104,7 +1538,7 @@ export function createChecker(program) {
         }
         if (node.kind === SyntaxKind.NamespaceStatement) {
             if (isArray(node.statements)) {
-                node.statements.forEach((x) => getTypeForNode(x));
+                node.statements.forEach((x) => checkNode(x));
             }
             else if (node.statements) {
                 const subNs = checkNamespace(node.statements);
@@ -1397,7 +1831,10 @@ export function createChecker(program) {
                     break;
                 }
                 compilerAssert(node.parent, "Parent expected.");
-                const containerType = getTypeForNode(node.parent, mapper);
+                const containerType = getTypeOrValueForNode(node.parent, mapper);
+                if (containerType === null || isValue(containerType)) {
+                    return undefined;
+                }
                 if (isAnonymous(containerType)) {
                     return undefined; // member of anonymous type cannot be referenced.
                 }
@@ -1746,9 +2183,9 @@ export function createChecker(program) {
             }));
             return undefined;
         }
-        else if (base.flags & 674 /* SymbolFlags.MemberContainer */) {
+        else if (base.flags & 682 /* SymbolFlags.MemberContainer */) {
             if (options.checkTemplateTypes && isTemplatedNode(base.declarations[0])) {
-                const type = base.flags & 16777216 /* SymbolFlags.LateBound */
+                const type = base.flags & 67108864 /* SymbolFlags.LateBound */
                     ? base.type
                     : getTypeForNode(base.declarations[0], mapper);
                 if (isTemplateInstance(type)) {
@@ -1863,17 +2300,112 @@ export function createChecker(program) {
         }
     }
     function checkStringTemplateExpresion(node, mapper) {
-        const spans = [createTemplateSpanLiteral(node.head)];
-        for (const span of node.spans) {
-            spans.push(createTemplateSpanValue(span.expression, mapper));
-            spans.push(createTemplateSpanLiteral(span.literal));
+        let hasType = false;
+        let hasValue = false;
+        const spanTypeOrValues = node.spans.map((span) => [span, checkNode(span.expression, mapper)]);
+        for (const [_, typeOrValue] of spanTypeOrValues) {
+            if (typeOrValue !== null) {
+                if (isValue(typeOrValue)) {
+                    hasValue = true;
+                }
+                else if ("kind" in typeOrValue && typeOrValue.kind === "TemplateParameter") {
+                    if (typeOrValue.constraint) {
+                        if (typeOrValue.constraint.valueType) {
+                            hasValue = true;
+                        }
+                        if (typeOrValue.constraint.type) {
+                            hasType = true;
+                        }
+                    }
+                    else {
+                        hasType = true;
+                    }
+                }
+                else {
+                    hasType = true;
+                }
+            }
+        }
+        if (hasType && hasValue) {
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "mixed-string-template",
+                target: node,
+            }));
+            return null;
+        }
+        if (hasValue) {
+            let str = node.head.value;
+            for (const [span, typeOrValue] of spanTypeOrValues) {
+                if (typeOrValue !== null &&
+                    (!("kind" in typeOrValue) || typeOrValue.kind !== "TemplateParameter")) {
+                    compilerAssert(typeOrValue !== null && isValue(typeOrValue), "Expected value.");
+                    str += stringifyValueForTemplate(typeOrValue);
+                }
+                str += span.literal.value;
+            }
+            return checkStringValue(createLiteralType(str), undefined, node);
+        }
+        else {
+            let hasNonStringElement = false;
+            let stringValue = node.head.value;
+            const spans = [createTemplateSpanLiteral(node.head)];
+            for (const [span, typeOrValue] of spanTypeOrValues) {
+                compilerAssert(typeOrValue !== null && !isValue(typeOrValue), "Expected type.");
+                const type = typeOrValue.entityKind === "Indeterminate" ? typeOrValue.type : typeOrValue;
+                const spanValue = createTemplateSpanValue(span.expression, type);
+                spans.push(spanValue);
+                const spanValueAsString = stringifyTypeForTemplate(type);
+                if (spanValueAsString) {
+                    stringValue += spanValueAsString;
+                }
+                else {
+                    hasNonStringElement = true;
+                }
+                spans.push(createTemplateSpanLiteral(span.literal));
+                stringValue += span.literal.value;
+            }
+            return createIndeterminateEntity(createType({
+                kind: "StringTemplate",
+                node,
+                spans,
+                stringValue: hasNonStringElement ? undefined : stringValue,
+            }));
+        }
+    }
+    function createIndeterminateEntity(type) {
+        return {
+            entityKind: "Indeterminate",
+            type,
+        };
+    }
+    function stringifyTypeForTemplate(type) {
+        switch (type.kind) {
+            case "String":
+            case "Number":
+            case "Boolean":
+                return String(type.value);
+            case "StringTemplate":
+                if (type.stringValue !== undefined) {
+                    return type.stringValue;
+                }
+                return undefined;
+            default:
+                return undefined;
+        }
+    }
+    function stringifyValueForTemplate(value) {
+        switch (value.valueKind) {
+            case "StringValue":
+            case "NumericValue":
+            case "BooleanValue":
+                return value.value.toString();
+            default:
+                reportCheckerDiagnostic(createDiagnostic({
+                    code: "non-literal-string-template",
+                    target: value,
+                }));
+                return `[${value.valueKind}]`;
         }
-        const type = createType({
-            kind: "StringTemplate",
-            node,
-            spans,
-        });
-        return type;
     }
     function createTemplateSpanLiteral(node) {
         return createType({
@@ -1883,22 +2415,31 @@ export function createChecker(program) {
             type: getLiteralType(node),
         });
     }
-    function createTemplateSpanValue(node, mapper) {
+    function createTemplateSpanValue(node, type) {
         return createType({
             kind: "StringTemplateSpan",
             node: node,
             isInterpolated: true,
-            type: getTypeForNode(node, mapper),
+            type: type,
         });
     }
     function checkStringLiteral(str) {
-        return getLiteralType(str);
+        return {
+            entityKind: "Indeterminate",
+            type: getLiteralType(str),
+        };
     }
     function checkNumericLiteral(num) {
-        return getLiteralType(num);
+        return {
+            entityKind: "Indeterminate",
+            type: getLiteralType(num),
+        };
     }
     function checkBooleanLiteral(bool) {
-        return getLiteralType(bool);
+        return {
+            entityKind: "Indeterminate",
+            type: getLiteralType(bool),
+        };
     }
     function checkProgram() {
         program.reportDuplicateSymbols(globalNamespaceNode.symbol.exports);
@@ -1947,7 +2488,7 @@ export function createChecker(program) {
     }
     function checkSourceFile(file) {
         for (const statement of file.statements) {
-            getTypeForNode(statement, undefined);
+            checkNode(statement, undefined);
         }
     }
     /**
@@ -2056,7 +2597,8 @@ export function createChecker(program) {
             return false;
         }
         // Some of the mapper args are still template parameter so we shouldn't create the type.
-        return !mapper.partial && mapper.args.every((t) => t.kind !== "TemplateParameter");
+        return (!mapper.partial &&
+            mapper.args.every((t) => isValue(t) || t.entityKind === "Indeterminate" || t.kind !== "TemplateParameter"));
     }
     function checkModelExpression(node, mapper) {
         const properties = createRekeyableMap();
@@ -2149,6 +2691,414 @@ export function createChecker(program) {
             };
         }
     }
+    function checkObjectValue(node, mapper, constraint) {
+        const properties = checkObjectLiteralProperties(node, mapper);
+        if (properties === null) {
+            return null;
+        }
+        const preciseType = createTypeForObjectValue(node, properties);
+        if (constraint && !checkTypeOfValueMatchConstraint(preciseType, constraint, node)) {
+            return null;
+        }
+        return {
+            entityKind: "Value",
+            valueKind: "ObjectValue",
+            node: node,
+            properties,
+            type: constraint ? constraint.type : preciseType,
+        };
+    }
+    function createTypeForObjectValue(node, properties) {
+        const model = createType({
+            kind: "Model",
+            name: "",
+            node,
+            properties: createRekeyableMap(),
+            decorators: [],
+            derivedModels: [],
+            sourceModels: [],
+        });
+        for (const prop of properties.values()) {
+            model.properties.set(prop.name, createModelPropertyForObjectPropertyDescriptor(prop, model));
+        }
+        return finishType(model);
+    }
+    function createModelPropertyForObjectPropertyDescriptor(prop, parentModel) {
+        return createAndFinishType({
+            kind: "ModelProperty",
+            node: prop.node,
+            model: parentModel,
+            optional: false,
+            name: prop.name,
+            type: prop.value.type,
+            decorators: [],
+        });
+    }
+    function checkObjectLiteralProperties(node, mapper) {
+        const properties = new Map();
+        let hasError = false;
+        for (const prop of node.properties) {
+            if ("id" in prop) {
+                const value = getValueForNode(prop.value, mapper);
+                if (value === null) {
+                    hasError = true;
+                }
+                else {
+                    properties.set(prop.id.sv, { name: prop.id.sv, value: value, node: prop });
+                }
+            }
+            else {
+                const targetType = checkObjectSpreadProperty(prop.target, mapper);
+                if (targetType) {
+                    for (const [name, value] of targetType.properties) {
+                        properties.set(name, { ...value });
+                    }
+                }
+            }
+        }
+        return hasError ? null : properties;
+    }
+    function checkObjectSpreadProperty(targetNode, mapper) {
+        const value = getValueForNode(targetNode, mapper);
+        if (value === null) {
+            return null;
+        }
+        if (value.valueKind !== "ObjectValue") {
+            reportCheckerDiagnostic(createDiagnostic({ code: "spread-object", target: targetNode }));
+            return null;
+        }
+        return value;
+    }
+    function checkArrayValue(node, mapper, constraint) {
+        let hasError = false;
+        const values = node.values.map((itemNode) => {
+            const value = getValueForNode(itemNode, mapper);
+            if (value === null) {
+                hasError = true;
+            }
+            return value;
+        });
+        if (hasError) {
+            return null;
+        }
+        const preciseType = createTypeForArrayValue(node, values);
+        if (constraint && !checkTypeOfValueMatchConstraint(preciseType, constraint, node)) {
+            return null;
+        }
+        return {
+            entityKind: "Value",
+            valueKind: "ArrayValue",
+            node: node,
+            values: values,
+            type: constraint ? constraint.type : preciseType,
+        };
+    }
+    function createTypeForArrayValue(node, values) {
+        return createAndFinishType({
+            kind: "Tuple",
+            node,
+            values: values.map((x) => x.type),
+        });
+    }
+    function inferScalarForPrimitiveValue(type, literalType) {
+        if (type === undefined) {
+            return undefined;
+        }
+        switch (type.kind) {
+            case "Scalar":
+                if (ignoreDiagnostics(isTypeAssignableTo(literalType, type, literalType))) {
+                    return type;
+                }
+                return undefined;
+            case "Union":
+                let found = undefined;
+                for (const variant of type.variants.values()) {
+                    const scalar = inferScalarForPrimitiveValue(variant.type, literalType);
+                    if (scalar) {
+                        if (found) {
+                            reportCheckerDiagnostic(createDiagnostic({
+                                code: "ambiguous-scalar-type",
+                                format: {
+                                    value: getTypeName(literalType),
+                                    types: [found, scalar].map((x) => x.name).join(", "),
+                                    example: found.name,
+                                },
+                                target: literalType,
+                            }));
+                            return undefined;
+                        }
+                        else {
+                            found = scalar;
+                        }
+                    }
+                }
+                return found;
+            default:
+                return undefined;
+        }
+    }
+    function checkStringValue(literalType, constraint, node) {
+        if (constraint && !checkTypeOfValueMatchConstraint(literalType, constraint, node)) {
+            return null;
+        }
+        let value;
+        if (literalType.kind === "StringTemplate") {
+            if (literalType.stringValue) {
+                value = literalType.stringValue;
+            }
+            else {
+                reportCheckerDiagnostics(explainStringTemplateNotSerializable(literalType));
+                return null;
+            }
+        }
+        else {
+            value = literalType.value;
+        }
+        const scalar = inferScalarForPrimitiveValue(constraint?.type, literalType);
+        return {
+            entityKind: "Value",
+            valueKind: "StringValue",
+            value,
+            type: constraint ? constraint.type : literalType,
+            scalar,
+        };
+    }
+    function checkNumericValue(literalType, constraint, node) {
+        if (constraint && !checkTypeOfValueMatchConstraint(literalType, constraint, node)) {
+            return null;
+        }
+        const scalar = inferScalarForPrimitiveValue(constraint?.type, literalType);
+        return {
+            entityKind: "Value",
+            valueKind: "NumericValue",
+            value: Numeric(literalType.valueAsString),
+            type: constraint ? constraint.type : literalType,
+            scalar,
+        };
+    }
+    function checkBooleanValue(literalType, constraint, node) {
+        if (constraint && !checkTypeOfValueMatchConstraint(literalType, constraint, node)) {
+            return null;
+        }
+        const scalar = inferScalarForPrimitiveValue(constraint?.type, literalType);
+        return {
+            entityKind: "Value",
+            valueKind: "BooleanValue",
+            value: literalType.value,
+            type: constraint ? constraint.type : literalType,
+            scalar,
+        };
+    }
+    function checkNullValue(literalType, constraint, node) {
+        if (constraint && !checkTypeOfValueMatchConstraint(literalType, constraint, node)) {
+            return null;
+        }
+        return {
+            entityKind: "Value",
+            valueKind: "NullValue",
+            type: constraint ? constraint.type : literalType,
+            value: null,
+        };
+    }
+    function checkEnumValue(literalType, constraint, node) {
+        if (constraint && !checkTypeOfValueMatchConstraint(literalType, constraint, node)) {
+            return null;
+        }
+        return {
+            entityKind: "Value",
+            valueKind: "EnumValue",
+            type: constraint ? constraint.type : literalType,
+            value: literalType,
+        };
+    }
+    function checkCallExpressionTarget(node, mapper) {
+        const target = checkTypeReference(node.target, mapper);
+        if (target.kind === "Scalar" || target.kind === "ScalarConstructor") {
+            return target;
+        }
+        else {
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "non-callable",
+                format: { type: target.kind },
+                target: node.target,
+            }));
+            return null;
+        }
+    }
+    /** Check the arguments of the call expression are a single value of the given syntax. */
+    function checkPrimitiveArg(node, scalar, valueKind) {
+        if (node.arguments.length !== 1) {
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "invalid-primitive-init",
+                target: node.target,
+            }));
+            return null;
+        }
+        const argNode = node.arguments[0];
+        const value = getValueForNode(argNode, undefined);
+        if (value === null) {
+            return null; // error should already have been reported above.
+        }
+        if (value.valueKind !== valueKind) {
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "invalid-primitive-init",
+                messageId: "invalidArg",
+                format: { actual: value.valueKind, expected: valueKind },
+                target: argNode,
+            }));
+            return null;
+        }
+        if (!checkValueOfType(value, scalar, argNode)) {
+            return null;
+        }
+        return { ...value, scalar, type: scalar };
+    }
+    function createScalarValue(node, mapper, declaration) {
+        let hasError = false;
+        const minArgs = declaration.parameters.filter((x) => !x.optional && !x.rest).length ?? 0;
+        const maxArgs = declaration.parameters[declaration.parameters.length - 1]?.rest
+            ? undefined
+            : declaration.parameters.length;
+        if (node.arguments.length < minArgs ||
+            (maxArgs !== undefined && node.arguments.length > maxArgs)) {
+            // In the case we have too little args then this decorator is not applicable.
+            // If there is too many args then we can still run the decorator as long as the args are valid.
+            if (node.arguments.length < minArgs) {
+                hasError = true;
+            }
+            if (maxArgs === undefined) {
+                reportCheckerDiagnostic(createDiagnostic({
+                    code: "invalid-argument-count",
+                    messageId: "atLeast",
+                    format: { actual: node.arguments.length.toString(), expected: minArgs.toString() },
+                    target: node,
+                }));
+            }
+            else {
+                const expected = minArgs === maxArgs ? minArgs.toString() : `${minArgs}-${maxArgs}`;
+                reportCheckerDiagnostic(createDiagnostic({
+                    code: "invalid-argument-count",
+                    format: { actual: node.arguments.length.toString(), expected },
+                    target: node,
+                }));
+            }
+        }
+        const resolvedArgs = [];
+        for (const [index, parameter] of declaration.parameters.entries()) {
+            if (parameter.rest) {
+                const restType = getIndexType(parameter.type);
+                if (restType) {
+                    for (let i = index; i < node.arguments.length; i++) {
+                        const argNode = node.arguments[i];
+                        if (argNode) {
+                            const arg = getValueForNode(argNode, mapper, { kind: "argument", type: restType });
+                            if (arg === null) {
+                                hasError = true;
+                                continue;
+                            }
+                            if (checkValueOfType(arg, restType, argNode)) {
+                                resolvedArgs.push(arg);
+                            }
+                            else {
+                                hasError = true;
+                            }
+                        }
+                    }
+                }
+                break;
+            }
+            const argNode = node.arguments[index];
+            if (argNode) {
+                const arg = getValueForNode(argNode, mapper, {
+                    kind: "argument",
+                    type: parameter.type,
+                });
+                if (arg === null) {
+                    hasError = true;
+                    continue;
+                }
+                if (checkValueOfType(arg, parameter.type, argNode)) {
+                    resolvedArgs.push(arg);
+                }
+                else {
+                    hasError = true;
+                }
+            }
+        }
+        if (hasError) {
+            return null;
+        }
+        return {
+            entityKind: "Value",
+            valueKind: "ScalarValue",
+            value: {
+                name: declaration.name,
+                args: resolvedArgs,
+            },
+            scalar: declaration.scalar,
+            type: declaration.scalar,
+        };
+    }
+    function checkCallExpression(node, mapper) {
+        const target = checkCallExpressionTarget(node, mapper);
+        if (target === null) {
+            return null;
+        }
+        if (target.kind === "ScalarConstructor") {
+            return createScalarValue(node, mapper, target);
+        }
+        if (areScalarsRelated(target, getStdType("string"))) {
+            return checkPrimitiveArg(node, target, "StringValue");
+        }
+        else if (areScalarsRelated(target, getStdType("numeric"))) {
+            return checkPrimitiveArg(node, target, "NumericValue");
+        }
+        else if (areScalarsRelated(target, getStdType("boolean"))) {
+            return checkPrimitiveArg(node, target, "BooleanValue");
+        }
+        else {
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "named-init-required",
+                format: { typeKind: target.kind },
+                target: node.target,
+            }));
+            return null;
+        }
+    }
+    function checkTypeOfExpression(node, mapper) {
+        const entity = checkNode(node.target, mapper, undefined);
+        if (entity === null) {
+            // Shouldn't need to emit error as we assume null value already emitted error when produced
+            return errorType;
+        }
+        if (entity.entityKind === "Indeterminate") {
+            return entity.type;
+        }
+        if (isType(entity)) {
+            if (entity.kind === "TemplateParameter") {
+                if (entity.constraint === undefined || entity.constraint.type !== undefined) {
+                    // means this template constraint will accept values
+                    reportCheckerDiagnostic(createDiagnostic({
+                        code: "expect-value",
+                        messageId: "templateConstraint",
+                        format: { name: getTypeName(entity) },
+                        target: node.target,
+                    }));
+                    return errorType;
+                }
+                else if (entity.constraint.valueType) {
+                    return entity.constraint.valueType;
+                }
+            }
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "expect-value",
+                format: { name: getTypeName(entity) },
+                target: node.target,
+            }));
+            return entity;
+        }
+        return entity.type;
+    }
     function createUnion(options) {
         const variants = createRekeyableMap();
         const union = createAndFinishType({
@@ -2229,6 +3179,15 @@ export function createChecker(program) {
                         }
                     }
                     break;
+                case SyntaxKind.ScalarStatement:
+                    if (node.extends && node.extends.kind === SyntaxKind.TypeReference) {
+                        resolveAndCopyMembers(node.extends);
+                    }
+                    for (const member of node.members) {
+                        const name = member.id.sv;
+                        bindMember(name, member, 33554432 /* SymbolFlags.ScalarMember */);
+                    }
+                    break;
                 case SyntaxKind.ModelExpression:
                     for (const prop of node.properties) {
                         if (prop.kind === SyntaxKind.ModelSpreadProperty) {
@@ -2356,7 +3315,7 @@ export function createChecker(program) {
                             const sigTable = getOrCreateAugmentedSymbolTable(sig.metatypeMembers);
                             const sigParameterSym = sigTable.get("parameters");
                             if (sigParameterSym !== undefined) {
-                                const parametersSym = createSymbol(sigParameterSym.declarations[0], "parameters", 2 /* SymbolFlags.Model */ & 674 /* SymbolFlags.MemberContainer */);
+                                const parametersSym = createSymbol(sigParameterSym.declarations[0], "parameters", 2 /* SymbolFlags.Model */ & 682 /* SymbolFlags.MemberContainer */);
                                 copyMembersToContainer(parametersSym, sigParameterSym.members);
                                 table.set("parameters", parametersSym);
                                 table.set("returnType", sigTable.get("returnType"));
@@ -2381,17 +3340,17 @@ export function createChecker(program) {
             return;
         switch (type.kind) {
             case "Model":
-                type.symbol = createSymbol(type.node, type.name, 2 /* SymbolFlags.Model */ | 16777216 /* SymbolFlags.LateBound */);
+                type.symbol = createSymbol(type.node, type.name, 2 /* SymbolFlags.Model */ | 67108864 /* SymbolFlags.LateBound */);
                 mutate(type.symbol).type = type;
                 break;
             case "Interface":
-                type.symbol = createSymbol(type.node, type.name, 128 /* SymbolFlags.Interface */ | 16777216 /* SymbolFlags.LateBound */);
+                type.symbol = createSymbol(type.node, type.name, 128 /* SymbolFlags.Interface */ | 67108864 /* SymbolFlags.LateBound */);
                 mutate(type.symbol).type = type;
                 break;
             case "Union":
                 if (!type.name)
                     return; // don't make a symbol for anonymous unions
-                type.symbol = createSymbol(type.node, type.name, 512 /* SymbolFlags.Union */ | 16777216 /* SymbolFlags.LateBound */);
+                type.symbol = createSymbol(type.node, type.name, 512 /* SymbolFlags.Union */ | 67108864 /* SymbolFlags.LateBound */);
                 mutate(type.symbol).type = type;
                 break;
         }
@@ -2404,6 +3363,11 @@ export function createChecker(program) {
                     lateBindMember(prop, 4 /* SymbolFlags.ModelProperty */);
                 }
                 break;
+            case "Scalar":
+                for (const member of type.constructors.values()) {
+                    lateBindMember(member, 33555780 /* SymbolFlags.Member */);
+                }
+                break;
             case "Enum":
                 for (const member of type.members.values()) {
                     lateBindMember(member, 64 /* SymbolFlags.EnumMember */);
@@ -2425,7 +3389,7 @@ export function createChecker(program) {
                 // don't bind anything for union expressions
                 return;
             }
-            const sym = createSymbol(member.node, member.name, kind | 16777216 /* SymbolFlags.LateBound */, containerSym);
+            const sym = createSymbol(member.node, member.name, kind | 67108864 /* SymbolFlags.LateBound */, containerSym);
             mutate(sym).type = member;
             compilerAssert(containerSym.members, "containerSym.members is undefined");
             containerMembers ??= getOrCreateAugmentedSymbolTable(containerSym.members);
@@ -2611,7 +3575,14 @@ export function createChecker(program) {
         else {
             pendingResolutions.start(symId, ResolutionKind.Type);
             type.type = getTypeForNode(prop.value, mapper);
-            type.default = prop.default && checkDefault(prop.default, type.type);
+            if (prop.default) {
+                const defaultValue = checkDefaultValue(prop.default, type.type);
+                if (defaultValue !== null) {
+                    type.defaultValue = defaultValue;
+                    // eslint-disable-next-line deprecation/deprecation
+                    type.default = checkLegacyDefault(prop.default);
+                }
+            }
             if (links) {
                 linkType(links, type, mapper);
             }
@@ -2641,43 +3612,42 @@ export function createChecker(program) {
             ],
         };
     }
-    function isValueType(type) {
-        if (type === nullType) {
-            return true;
-        }
-        if (type.kind === "StringTemplate") {
-            const [valid] = isStringTemplateSerializable(type);
-            return valid;
-        }
-        if (type.kind === "UnionVariant") {
-            return isValueType(type.type);
-        }
-        const valueTypes = new Set(["String", "Number", "Boolean", "EnumMember", "Tuple"]);
-        return valueTypes.has(type.kind);
-    }
-    function checkDefault(defaultNode, type) {
-        const defaultType = getTypeForNode(defaultNode, undefined);
+    function checkDefaultValue(defaultNode, type) {
         if (isErrorType(type)) {
-            return errorType;
+            // if the prop type is an error we don't need to validate again.
+            return null;
         }
-        if (!isValueType(defaultType)) {
-            reportCheckerDiagnostic(createDiagnostic({
-                code: "unsupported-default",
-                format: { type: defaultType.kind },
-                target: defaultNode,
-            }));
-            return errorType;
+        const defaultValue = getValueForNode(defaultNode, undefined, {
+            kind: "assignment",
+            type,
+        }, { legacyTupleAndModelCast: true });
+        if (defaultValue === null) {
+            return null;
         }
-        const [related, diagnostics] = isTypeAssignableTo(defaultType, type, defaultNode);
+        const [related, diagnostics] = isValueOfType(defaultValue, type, defaultNode);
         if (!related) {
             reportCheckerDiagnostics(diagnostics);
-            return errorType;
+            return null;
         }
         else {
-            return defaultType;
+            return { ...defaultValue, type };
+        }
+    }
+    /**
+     * Fill in the legacy `.default` property.
+     * We do do checking here we just keep existing behavior.
+     */
+    function checkLegacyDefault(defaultNode) {
+        const resolved = checkNode(defaultNode, undefined);
+        if (resolved === null || isValue(resolved)) {
+            return undefined;
         }
+        if (resolved.entityKind === "Indeterminate") {
+            return resolved.type;
+        }
+        return resolved;
     }
-    function checkDecorator(targetType, decNode, mapper) {
+    function checkDecoratorApplication(targetType, decNode, mapper) {
         const sym = resolveTypeReferenceSym(decNode.target, undefined, true);
         if (!sym) {
             reportCheckerDiagnostic(createDiagnostic({
@@ -2695,7 +3665,6 @@ export function createChecker(program) {
             return undefined;
         }
         const symbolLinks = getSymbolLinks(sym);
-        let args = checkDecoratorArguments(decNode, mapper);
         let hasError = false;
         if (symbolLinks.declaredType === undefined) {
             const decoratorDeclNode = sym.declarations.find((x) => x.kind === SyntaxKind.DecoratorDeclarationStatement);
@@ -2705,10 +3674,12 @@ export function createChecker(program) {
         }
         if (symbolLinks.declaredType) {
             compilerAssert(symbolLinks.declaredType.kind === "Decorator", "Expected to find a decorator type.");
-            // Means we have a decorator declaration.
-            [hasError, args] = checkDecoratorUsage(targetType, symbolLinks.declaredType, args, decNode);
+            if (!checkDecoratorTarget(targetType, symbolLinks.declaredType, decNode)) {
+                hasError = true;
+            }
         }
-        if (hasError) {
+        const [argsHaveError, args] = checkDecoratorArguments(decNode, mapper, symbolLinks.declaredType);
+        if (hasError || argsHaveError) {
             return undefined;
         }
         return {
@@ -2718,62 +3689,121 @@ export function createChecker(program) {
             args,
         };
     }
-    function checkDecoratorUsage(targetType, declaration, args, decoratorNode) {
-        let hasError = false;
+    function resolveDecoratorArgMarshalling(declaredType) {
+        if (declaredType) {
+            const location = getLocationContext(program, declaredType);
+            if (location.type === "compiler") {
+                return "new";
+            }
+            else if ((location.type === "library" || location.type === "project") &&
+                location.flags?.decoratorArgMarshalling) {
+                return location.flags.decoratorArgMarshalling;
+            }
+            else {
+                return "legacy";
+            }
+        }
+        return "new";
+    }
+    /** Check the decorator target is valid */
+    function checkDecoratorTarget(targetType, declaration, decoratorNode) {
         const [targetValid] = isTypeAssignableTo(targetType, declaration.target.type, decoratorNode);
         if (!targetValid) {
-            hasError = true;
             reportCheckerDiagnostic(createDiagnostic({
                 code: "decorator-wrong-target",
                 messageId: "withExpected",
                 format: {
                     decorator: declaration.name,
                     to: getTypeName(targetType),
-                    expected: getTypeName(declaration.target.type),
+                    expected: getEntityName(declaration.target.type),
                 },
                 target: decoratorNode,
             }));
         }
-        const minArgs = declaration.parameters.filter((x) => !x.optional && !x.rest).length;
+        return targetValid;
+    }
+    function checkDecoratorArguments(node, mapper, declaration) {
+        // if we don't have a declaration we can just return the types or values if
+        if (declaration === undefined) {
+            return [
+                false,
+                node.arguments.map((argNode) => {
+                    let type = checkNode(argNode, mapper) ?? errorType;
+                    if (type.entityKind === "Indeterminate") {
+                        type = type.type;
+                    }
+                    return {
+                        value: type,
+                        jsValue: type,
+                        node: argNode,
+                    };
+                }),
+            ];
+        }
+        let hasError = false;
+        const minArgs = declaration.parameters.filter((x) => !x.optional && !x.rest).length ?? 0;
         const maxArgs = declaration.parameters[declaration.parameters.length - 1]?.rest
             ? undefined
             : declaration.parameters.length;
-        if (args.length < minArgs || (maxArgs !== undefined && args.length > maxArgs)) {
+        if (node.arguments.length < minArgs ||
+            (maxArgs !== undefined && node.arguments.length > maxArgs)) {
             // In the case we have too little args then this decorator is not applicable.
             // If there is too many args then we can still run the decorator as long as the args are valid.
-            if (args.length < minArgs) {
+            if (node.arguments.length < minArgs) {
                 hasError = true;
             }
             if (maxArgs === undefined) {
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "invalid-argument-count",
                     messageId: "atLeast",
-                    format: { actual: args.length.toString(), expected: minArgs.toString() },
-                    target: decoratorNode,
+                    format: { actual: node.arguments.length.toString(), expected: minArgs.toString() },
+                    target: node,
                 }));
             }
             else {
                 const expected = minArgs === maxArgs ? minArgs.toString() : `${minArgs}-${maxArgs}`;
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "invalid-argument-count",
-                    format: { actual: args.length.toString(), expected },
-                    target: decoratorNode,
+                    format: { actual: node.arguments.length.toString(), expected },
+                    target: node,
                 }));
             }
         }
         const resolvedArgs = [];
+        const jsMarshalling = resolveDecoratorArgMarshalling(declaration);
+        function resolveArg(argNode, perParamType) {
+            const arg = getTypeOrValueForNode(argNode, mapper, {
+                kind: "argument",
+                constraint: perParamType,
+            });
+            if (arg !== null &&
+                !(isType(arg) && isErrorType(arg)) &&
+                checkArgumentAssignable(arg, perParamType, argNode)) {
+                return {
+                    value: arg,
+                    node: argNode,
+                    jsValue: resolveDecoratorArgJsValue(arg, extractValueOfConstraints({
+                        kind: "argument",
+                        constraint: perParamType,
+                    }), jsMarshalling),
+                };
+            }
+            else {
+                return undefined;
+            }
+        }
         for (const [index, parameter] of declaration.parameters.entries()) {
             if (parameter.rest) {
-                const restType = getIndexType(parameter.type.kind === "Value" ? parameter.type.target : parameter.type);
+                const restType = extractRestParamConstraint(parameter.type);
                 if (restType) {
-                    for (let i = index; i < args.length; i++) {
-                        const arg = args[i];
-                        if (arg && arg.value) {
-                            resolvedArgs.push({
-                                ...arg,
-                                jsValue: resolveDecoratorArgJsValue(arg.value, parameter.type.kind === "Value"),
-                            });
-                            if (!checkArgumentAssignable(arg.value, restType, arg.node)) {
+                    for (let i = index; i < node.arguments.length; i++) {
+                        const argNode = node.arguments[i];
+                        if (argNode) {
+                            const arg = resolveArg(argNode, restType);
+                            if (arg) {
+                                resolvedArgs.push(arg);
+                            }
+                            else {
                                 hasError = true;
                             }
                         }
@@ -2781,29 +3811,58 @@ export function createChecker(program) {
                 }
                 break;
             }
-            const arg = args[index];
-            if (arg && arg.value) {
-                resolvedArgs.push({
-                    ...arg,
-                    jsValue: resolveDecoratorArgJsValue(arg.value, parameter.type.kind === "Value"),
-                });
-                if (!checkArgumentAssignable(arg.value, parameter.type, arg.node)) {
+            const argNode = node.arguments[index];
+            if (argNode) {
+                const arg = resolveArg(argNode, parameter.type);
+                if (arg) {
+                    resolvedArgs.push(arg);
+                }
+                else {
                     hasError = true;
                 }
             }
         }
         return [hasError, resolvedArgs];
     }
+    /** For a rest param of constraint T[] or valueof T[] return the T or valueof T */
+    function extractRestParamConstraint(constraint) {
+        let valueType;
+        let type;
+        if (constraint.valueType) {
+            if (constraint.valueType.kind === "Model" &&
+                isArrayModelType(program, constraint.valueType)) {
+                valueType = constraint.valueType.indexer.value;
+            }
+            else {
+                return undefined;
+            }
+        }
+        if (constraint.type) {
+            if (constraint.type.kind === "Model" && isArrayModelType(program, constraint.type)) {
+                type = constraint.type.indexer.value;
+            }
+            else {
+                return undefined;
+            }
+        }
+        return {
+            entityKind: "MixedParameterConstraint",
+            type,
+            valueType,
+        };
+    }
     function getIndexType(type) {
         return type.kind === "Model" ? type.indexer?.value : undefined;
     }
-    function resolveDecoratorArgJsValue(value, valueOf) {
-        if (valueOf) {
-            if (value.kind === "Boolean" || value.kind === "String" || value.kind === "Number") {
-                return literalTypeToValue(value);
+    function resolveDecoratorArgJsValue(value, valueConstraint, jsMarshalling) {
+        if (valueConstraint !== undefined) {
+            if (isValue(value)) {
+                return jsMarshalling === "legacy"
+                    ? legacyMarshallTypeForJS(checker, value)
+                    : marshallTypeForJS(value, valueConstraint.type);
             }
-            else if (value.kind === "StringTemplate") {
-                return stringTemplateToString(value)[0];
+            else {
+                return value;
             }
         }
         return value;
@@ -2814,8 +3873,8 @@ export function createChecker(program) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "invalid-argument",
                 format: {
-                    value: getTypeName(argumentType),
-                    expected: getTypeName(parameterType),
+                    value: getEntityName(argumentType),
+                    expected: getEntityName(parameterType),
                 },
                 target: diagnosticTarget,
             }));
@@ -2826,7 +3885,7 @@ export function createChecker(program) {
         const augmentDecoratorNodes = augmentDecoratorsForSym.get(sym) ?? [];
         const decorators = [];
         for (const decNode of augmentDecoratorNodes) {
-            const decorator = checkDecorator(targetType, decNode, mapper);
+            const decorator = checkDecoratorApplication(targetType, decNode, mapper);
             if (decorator) {
                 decorators.unshift(decorator);
             }
@@ -2842,7 +3901,7 @@ export function createChecker(program) {
             ...node.decorators,
         ];
         for (const decNode of decoratorNodes) {
-            const decorator = checkDecorator(targetType, decNode, mapper);
+            const decorator = checkDecoratorApplication(targetType, decNode, mapper);
             if (decorator) {
                 decorators.unshift(decorator);
             }
@@ -2863,16 +3922,6 @@ export function createChecker(program) {
         }
         return decorators;
     }
-    function checkDecoratorArguments(decorator, mapper) {
-        return decorator.arguments.map((argNode) => {
-            const type = getTypeForNode(argNode, mapper);
-            return {
-                value: type,
-                jsValue: type,
-                node: argNode,
-            };
-        });
-    }
     function checkScalar(node, mapper) {
         const links = getSymbolLinks(node.symbol);
         if (links.declaredType && mapper === undefined) {
@@ -2885,10 +3934,12 @@ export function createChecker(program) {
             kind: "Scalar",
             name: node.id.sv,
             node: node,
+            constructors: new Map(),
             namespace: getParentNamespaceType(node),
             decorators,
             derivedScalars: [],
         });
+        checkScalarConstructors(type, node, type.constructors, mapper);
         linkType(links, type, mapper);
         if (node.extends) {
             type.baseScalar = checkScalarExtends(node, node.extends, mapper);
@@ -2939,6 +3990,43 @@ export function createChecker(program) {
         }
         return extendsType;
     }
+    function checkScalarConstructors(parentScalar, node, constructors, mapper) {
+        for (const member of node.members) {
+            const constructor = checkScalarConstructor(member, mapper, parentScalar);
+            if (constructors.has(constructor.name)) {
+                reportCheckerDiagnostic(createDiagnostic({
+                    code: "constructor-duplicate",
+                    format: { name: constructor.name.toString() },
+                    target: member,
+                }));
+                continue;
+            }
+            constructors.set(constructor.name, constructor);
+        }
+    }
+    function checkScalarConstructor(node, mapper, parentScalar) {
+        const name = node.id.sv;
+        const links = getSymbolLinksForMember(node);
+        if (links && links.declaredType && mapper === undefined) {
+            // we're not instantiating this scalar constructor and we've already checked it
+            return links.declaredType;
+        }
+        const member = createType({
+            kind: "ScalarConstructor",
+            scalar: parentScalar,
+            name,
+            node,
+            parameters: node.parameters.map((x) => checkFunctionParameter(x, mapper, false)),
+        });
+        linkMapper(member, mapper);
+        if (shouldCreateTypeForTemplate(node.parent, mapper)) {
+            finishType(member);
+        }
+        if (links) {
+            linkType(links, member, mapper);
+        }
+        return finishType(member);
+    }
     function checkAlias(node, mapper) {
         const links = getSymbolLinks(node.symbol);
         if (links.declaredType && mapper === undefined) {
@@ -2959,10 +4047,55 @@ export function createChecker(program) {
         }
         pendingResolutions.start(aliasSymId, ResolutionKind.Type);
         const type = getTypeForNode(node.value, mapper);
-        linkType(links, type, mapper);
+        if (!isValue(type)) {
+            linkType(links, type, mapper);
+        }
         pendingResolutions.finish(aliasSymId, ResolutionKind.Type);
         return type;
     }
+    function checkConst(node) {
+        const links = getSymbolLinks(node.symbol);
+        if (links.value !== undefined) {
+            return links.value;
+        }
+        const type = node.type ? getTypeForNode(node.type, undefined) : undefined;
+        const symId = getSymbolId(node.symbol);
+        if (pendingResolutions.has(symId, ResolutionKind.Value)) {
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "circular-const",
+                format: { name: node.id.sv },
+                target: node,
+            }));
+            return null;
+        }
+        pendingResolutions.start(symId, ResolutionKind.Value);
+        const value = getValueForNode(node.value, undefined, type && { kind: "assignment", type });
+        pendingResolutions.finish(symId, ResolutionKind.Value);
+        if (value === null || (type && !checkValueOfType(value, type, node.id))) {
+            links.value = null;
+            return links.value;
+        }
+        links.value = type ? { ...value, type } : { ...value };
+        return links.value;
+    }
+    function inferScalarsFromConstraints(value, type) {
+        switch (value.valueKind) {
+            case "BooleanValue":
+            case "StringValue":
+            case "NumericValue":
+                if (value.scalar === undefined) {
+                    const scalar = inferScalarForPrimitiveValue(type, value.type);
+                    return { ...value, scalar };
+                }
+                return value;
+            case "ArrayValue":
+            case "ObjectValue":
+            case "EnumValue":
+            case "NullValue":
+            case "ScalarValue":
+                return value;
+        }
+    }
     function checkEnum(node, mapper) {
         const links = getSymbolLinks(node.symbol);
         if (!links.type) {
@@ -3279,6 +4412,7 @@ export function createChecker(program) {
         // If the type has an associated syntax node, check any directives that
         // might be attached.
         const createdType = typeDef;
+        createdType.entityKind = "Type";
         if (createdType.node) {
             checkDirectives(createdType.node, createdType);
         }
@@ -4024,6 +5158,7 @@ export function createChecker(program) {
                     kind: "Number",
                     value,
                     valueAsString,
+                    numericValue: Numeric(valueAsString),
                 });
                 break;
         }
@@ -4036,7 +5171,7 @@ export function createChecker(program) {
             throw new ProjectionError("Can't find decorator.");
         compilerAssert(ref.flags & 16384 /* SymbolFlags.Decorator */, "should only resolve decorator symbols");
         return createFunctionType((...args) => {
-            ref.value({ program }, ...marshalArgumentsForJS(args));
+            ref.value({ program }, ...args.map(unsafe_projectionArgumentMarshalForJS));
             return voidType;
         });
     }
@@ -4061,7 +5196,7 @@ export function createChecker(program) {
         else if (ref.flags & 131072 /* SymbolFlags.Function */) {
             // TODO: store this in a symbol link probably?
             const t = createFunctionType((...args) => {
-                const retval = ref.value(program, ...marshalArgumentsForJS(args));
+                const retval = ref.value(program, ...args.map(unsafe_projectionArgumentMarshalForJS));
                 return marshalProjectionReturn(retval, { functionName: node.sv });
             });
             return t;
@@ -4135,6 +5270,31 @@ export function createChecker(program) {
         parts.push(current.sv);
         return parts.reverse().join(".");
     }
+    /**
+     * Check if the source type can be assigned to the target type and emit diagnostics
+     * @param source Type of a value
+     * @param constraint
+     * @param diagnosticTarget Target for the diagnostic, unless something better can be inferred.
+     */
+    function checkTypeOfValueMatchConstraint(source, constraint, diagnosticTarget) {
+        const [related, diagnostics] = isTypeAssignableTo(source, constraint.type, diagnosticTarget);
+        if (!related) {
+            if (constraint.kind === "argument") {
+                reportCheckerDiagnostic(createDiagnostic({
+                    code: "invalid-argument",
+                    format: {
+                        value: getEntityName(source),
+                        expected: getEntityName(constraint.type),
+                    },
+                    target: diagnosticTarget,
+                }));
+            }
+            else {
+                reportCheckerDiagnostics(diagnostics);
+            }
+        }
+        return related;
+    }
     /**
      * Check if the source type can be assigned to the target type and emit diagnostics
      * @param source Source type
@@ -4148,6 +5308,13 @@ export function createChecker(program) {
         }
         return related;
     }
+    function checkValueOfType(source, target, diagnosticTarget) {
+        const [related, diagnostics] = isValueOfType(source, target, diagnosticTarget);
+        if (!related) {
+            reportCheckerDiagnostics(diagnostics);
+        }
+        return related;
+    }
     /**
      * Check if the source type can be assigned to the target type.
      * @param source Source type
@@ -4158,6 +5325,16 @@ export function createChecker(program) {
         const [related, diagnostics] = isTypeAssignableToInternal(source, target, diagnosticTarget, new MultiKeyMap());
         return [related === Related.true, diagnostics];
     }
+    /**
+     * Check if the given Value type is of the given type.
+     * @param source Value
+     * @param target Target type
+     * @param diagnosticTarget Target for the diagnostic, unless something better can be inferred.
+     */
+    function isValueOfType(source, target, diagnosticTarget) {
+        const [related, diagnostics] = isValueOfTypeInternal(source, target, diagnosticTarget, new MultiKeyMap());
+        return [related === Related.true, diagnostics];
+    }
     function isTypeAssignableToInternal(source, target, diagnosticTarget, relationCache) {
         const cached = relationCache.get([source, target]);
         if (cached !== undefined) {
@@ -4168,26 +5345,44 @@ export function createChecker(program) {
         return [result, diagnostics];
     }
     function isTypeAssignableToWorker(source, target, diagnosticTarget, relationCache) {
-        // BACKCOMPAT: Added May 2023 sprint, to be removed by June 2023 sprint
-        if (source.kind === "TemplateParameter" && source.constraint && target.kind === "Value") {
-            const [assignable] = isTypeAssignableToInternal(source.constraint, target.target, diagnosticTarget, relationCache);
+        // BACKCOMPAT: Allow certain type to be accepted as values
+        if ("kind" in source &&
+            "entityKind" in target &&
+            source.kind === "TemplateParameter" &&
+            source.constraint?.type &&
+            source.constraint.valueType === undefined &&
+            target.entityKind === "MixedParameterConstraint" &&
+            target.valueType) {
+            const [assignable] = isTypeAssignableToInternal(source.constraint.type, target.valueType, diagnosticTarget, relationCache);
             if (assignable) {
-                const constraint = getTypeName(source.constraint);
-                reportDeprecated(program, `Template constrainted to '${constraint}' will not be assignable to '${getTypeName(target)}' in the future. Update the constraint to be 'valueof ${constraint}'`, diagnosticTarget);
+                const constraint = getEntityName(source.constraint);
+                reportDeprecated(program, `Template constrainted to '${constraint}' will not be assignable to '${getEntityName(target)}' in the future. Update the constraint to be 'valueof ${constraint}'`, diagnosticTarget);
                 return [Related.true, []];
             }
         }
-        while (source.kind === "TemplateParameter" && source.constraint !== source) {
+        if ("kind" in source && source.kind === "TemplateParameter") {
             source = source.constraint ?? unknownType;
         }
+        if (target.entityKind === "Indeterminate") {
+            target = target.type;
+        }
         if (source === target)
             return [Related.true, []];
-        if (target.kind === "Value") {
-            return isAssignableToValueType(source, target, diagnosticTarget, relationCache);
+        if (isValue(target)) {
+            return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
+        }
+        if (source.entityKind === "Indeterminate") {
+            return isIndeterminateEntityAssignableTo(source, target, diagnosticTarget, relationCache);
         }
-        if (source.kind === "Value") {
+        if (target.entityKind === "MixedParameterConstraint") {
+            return isAssignableToMixedParameterConstraint(source, target, diagnosticTarget, relationCache);
+        }
+        if (isValue(source) || (source.entityKind === "MixedParameterConstraint" && source.valueType)) {
             return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
         }
+        if (source.entityKind === "MixedParameterConstraint") {
+            return isTypeAssignableToInternal(source.type, target, diagnosticTarget, relationCache);
+        }
         const isSimpleTypeRelated = isSimpleTypeAssignableTo(source, target);
         if (isSimpleTypeRelated === true) {
             return [Related.true, []];
@@ -4227,19 +5422,21 @@ export function createChecker(program) {
         else if (target.kind === "Model" &&
             isArrayModelType(program, target) &&
             source.kind === "Model") {
-            return hasIndexAndIsAssignableTo(source, target, diagnosticTarget, relationCache);
+            if (isArrayModelType(program, source)) {
+                return hasIndexAndIsAssignableTo(source, target, diagnosticTarget, relationCache);
+            }
+            else {
+                // For other models just fallback to unassignable
+                return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
+            }
         }
         else if (target.kind === "Model" && source.kind === "Model") {
             return isModelRelatedTo(source, target, diagnosticTarget, relationCache);
         }
-        else if (target.kind === "Model" && target.indexer && source.kind === "Tuple") {
-            for (const item of source.values) {
-                const [related, diagnostics] = isTypeAssignableToInternal(item, target.indexer.value, diagnosticTarget, relationCache);
-                if (!related) {
-                    return [Related.false, diagnostics];
-                }
-            }
-            return [Related.true, []];
+        else if (target.kind === "Model" &&
+            isArrayModelType(program, target) &&
+            source.kind === "Tuple") {
+            return isTupleAssignableToArray(source, target, diagnosticTarget, relationCache);
         }
         else if (target.kind === "Tuple" && source.kind === "Tuple") {
             return isTupleAssignableToTuple(source, target, diagnosticTarget, relationCache);
@@ -4252,18 +5449,60 @@ export function createChecker(program) {
         }
         return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
     }
-    function isAssignableToValueType(source, target, diagnosticTarget, relationCache) {
-        if (source.kind === "Value") {
-            return isTypeAssignableToInternal(source.target, target.target, diagnosticTarget, relationCache);
+    function isIndeterminateEntityAssignableTo(indeterminate, target, diagnosticTarget, relationCache) {
+        const [typeRelated, typeDiagnostics] = isTypeAssignableToInternal(indeterminate.type, target, diagnosticTarget, relationCache);
+        if (typeRelated) {
+            return [Related.true, []];
         }
-        const [assignable, diagnostics] = isTypeAssignableToInternal(source, target.target, diagnosticTarget, relationCache);
-        if (!assignable) {
-            return [assignable, diagnostics];
+        if (target.entityKind === "MixedParameterConstraint" && target.valueType) {
+            const [valueRelated] = isTypeAssignableToInternal(indeterminate.type, target.valueType, diagnosticTarget, relationCache);
+            if (valueRelated) {
+                return [Related.true, []];
+            }
         }
-        if (!isValueType(source)) {
+        return [Related.false, typeDiagnostics];
+    }
+    function isAssignableToValueType(source, target, diagnosticTarget, relationCache) {
+        if (!isValue(source)) {
             return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
         }
-        return [Related.true, []];
+        return isValueOfTypeInternal(source, target, diagnosticTarget, relationCache);
+    }
+    function isAssignableToMixedParameterConstraint(source, target, diagnosticTarget, relationCache) {
+        if ("entityKind" in source && source.entityKind === "MixedParameterConstraint") {
+            if (source.type && target.type) {
+                const [variantAssignable, diagnostics] = isTypeAssignableToInternal(source.type, target.type, diagnosticTarget, relationCache);
+                if (variantAssignable === Related.false) {
+                    return [Related.false, diagnostics];
+                }
+                return [Related.true, []];
+            }
+            if (source.valueType && target.valueType) {
+                const [variantAssignable, diagnostics] = isTypeAssignableToInternal(source.valueType, target.valueType, diagnosticTarget, relationCache);
+                if (variantAssignable === Related.false) {
+                    return [Related.false, diagnostics];
+                }
+                return [Related.true, []];
+            }
+            return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
+        }
+        if (target.type) {
+            const [related] = isTypeAssignableToInternal(source, target.type, diagnosticTarget, relationCache);
+            if (related) {
+                return [Related.true, []];
+            }
+        }
+        if (target.valueType) {
+            const [related] = isAssignableToValueType(source, target.valueType, diagnosticTarget, relationCache);
+            if (related) {
+                return [Related.true, []];
+            }
+        }
+        return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
+    }
+    /** Check if the value is assignable to the given type. */
+    function isValueOfTypeInternal(source, target, diagnosticTarget, relationCache) {
+        return isTypeAssignableToInternal(source.type, target, diagnosticTarget, relationCache);
     }
     function isReflectionType(type) {
         return (type.kind === "Model" &&
@@ -4276,7 +5515,7 @@ export function createChecker(program) {
                 return isNumericLiteralRelatedTo(source, target);
             case "String":
             case "StringTemplate":
-                return areScalarsRelated(target, getStdType("string"));
+                return isStringLiteralRelatedTo(source, target);
             case "Boolean":
                 return areScalarsRelated(target, getStdType("boolean"));
             case "Scalar":
@@ -4314,7 +5553,12 @@ export function createChecker(program) {
             return false;
         }
         if (target.kind === "String") {
-            return source.kind === "String" && target.value === source.value;
+            return ((source.kind === "String" && source.value === target.value) ||
+                (source.kind === "StringTemplate" && source.stringValue === target.value));
+        }
+        if (target.kind === "StringTemplate" && target.stringValue) {
+            return ((source.kind === "String" && source.value === target.stringValue) ||
+                (source.kind === "StringTemplate" && source.stringValue === target.stringValue));
         }
         if (target.kind === "Number") {
             return source.kind === "Number" && target.value === source.value;
@@ -4322,6 +5566,29 @@ export function createChecker(program) {
         return undefined;
     }
     function isNumericLiteralRelatedTo(source, target) {
+        // First check that the source numeric literal is assignable to the target scalar
+        if (!isNumericAssignableToNumericScalar(source.numericValue, target)) {
+            return false;
+        }
+        const min = getMinValueAsNumeric(program, target);
+        const max = getMaxValueAsNumeric(program, target);
+        const minExclusive = getMinValueExclusiveAsNumeric(program, target);
+        const maxExclusive = getMaxValueExclusiveAsNumeric(program, target);
+        if (min && source.numericValue.lt(min)) {
+            return false;
+        }
+        if (minExclusive && source.numericValue.lte(minExclusive)) {
+            return false;
+        }
+        if (max && source.numericValue.gt(max)) {
+            return false;
+        }
+        if (maxExclusive && source.numericValue.gte(maxExclusive)) {
+            return false;
+        }
+        return true;
+    }
+    function isNumericAssignableToNumericScalar(source, target) {
         // if the target does not derive from numeric, then it can't be assigned a numeric literal
         if (!areScalarsRelated(target, getStdType("numeric"))) {
             return false;
@@ -4338,7 +5605,7 @@ export function createChecker(program) {
             return true;
         if (target.name === "decimal128")
             return true;
-        const isInt = Number.isInteger(source.value);
+        const isInt = source.isInteger;
         if (target.name === "integer")
             return isInt;
         if (target.name === "float")
@@ -4346,7 +5613,25 @@ export function createChecker(program) {
         if (!(target.name in numericRanges))
             return false;
         const [low, high, options] = numericRanges[target.name];
-        return source.value >= low && source.value <= high && (!options.int || isInt);
+        return source.gte(low) && source.lte(high) && (!options.int || isInt);
+    }
+    function isStringLiteralRelatedTo(source, target) {
+        if (!areScalarsRelated(target, getStdType("string"))) {
+            return false;
+        }
+        if (source.kind === "StringTemplate") {
+            return true;
+        }
+        const len = source.value.length;
+        const min = getMinLength(program, target);
+        const max = getMaxLength(program, target);
+        if (min && len < min) {
+            return false;
+        }
+        if (max && len > max) {
+            return false;
+        }
+        return true;
     }
     function isModelRelatedTo(source, target, diagnosticTarget, relationCache) {
         relationCache.set([source, target], Related.maybe);
@@ -4396,8 +5681,30 @@ export function createChecker(program) {
                 }
             }
         }
+        else if (shouldCheckExcessProperties(source)) {
+            for (const [propName, prop] of remainingProperties) {
+                if (shouldCheckExcessProperty(prop)) {
+                    diagnostics.push(createDiagnostic({
+                        code: "unexpected-property",
+                        format: {
+                            propertyName: propName,
+                            type: getEntityName(target),
+                        },
+                        target: prop,
+                    }));
+                }
+            }
+        }
         return [diagnostics.length === 0 ? Related.true : Related.false, diagnostics];
     }
+    /** If we should check for excess properties on the given model. */
+    function shouldCheckExcessProperties(model) {
+        return model.node?.kind === SyntaxKind.ObjectLiteral;
+    }
+    /** If we should check for this specific property */
+    function shouldCheckExcessProperty(prop) {
+        return (prop.node?.kind === SyntaxKind.ObjectLiteralProperty && prop.node.parent === prop.model?.node);
+    }
     function getProperty(model, name) {
         return (model.properties.get(name) ??
             (model.baseModel !== undefined ? getProperty(model.baseModel, name) : undefined));
@@ -4430,6 +5737,51 @@ export function createChecker(program) {
         }
         return isTypeAssignableToInternal(source.indexer.value, target.indexer.value, diagnosticTarget, relationCache);
     }
+    function isTupleAssignableToArray(source, target, diagnosticTarget, relationCache) {
+        const minItems = getMinItems(program, target);
+        const maxItems = getMaxItems(program, target);
+        if (minItems !== undefined && source.values.length < minItems) {
+            return [
+                Related.false,
+                [
+                    createDiagnostic({
+                        code: "unassignable",
+                        messageId: "withDetails",
+                        format: {
+                            sourceType: getEntityName(source),
+                            targetType: getTypeName(target),
+                            details: `Source has ${source.values.length} element(s) but target requires ${minItems}.`,
+                        },
+                        target: diagnosticTarget,
+                    }),
+                ],
+            ];
+        }
+        if (maxItems !== undefined && source.values.length > maxItems) {
+            return [
+                Related.false,
+                [
+                    createDiagnostic({
+                        code: "unassignable",
+                        messageId: "withDetails",
+                        format: {
+                            sourceType: getEntityName(source),
+                            targetType: getTypeName(target),
+                            details: `Source has ${source.values.length} element(s) but target only allows ${maxItems}.`,
+                        },
+                        target: diagnosticTarget,
+                    }),
+                ],
+            ];
+        }
+        for (const item of source.values) {
+            const [related, diagnostics] = isTypeAssignableToInternal(item, target.indexer.value, diagnosticTarget, relationCache);
+            if (!related) {
+                return [Related.false, diagnostics];
+            }
+        }
+        return [Related.true, []];
+    }
     function isTupleAssignableToTuple(source, target, diagnosticTarget, relationCache) {
         if (source.values.length !== target.values.length) {
             return [
@@ -4439,7 +5791,7 @@ export function createChecker(program) {
                         code: "unassignable",
                         messageId: "withDetails",
                         format: {
-                            sourceType: getTypeName(source),
+                            sourceType: getEntityName(source),
                             targetType: getTypeName(target),
                             details: `Source has ${source.values.length} element(s) but target requires ${target.values.length}.`,
                         },
@@ -4492,7 +5844,7 @@ export function createChecker(program) {
     function createUnassignableDiagnostic(source, target, diagnosticTarget) {
         return createDiagnostic({
             code: "unassignable",
-            format: { targetType: getTypeName(target), value: getTypeName(source) },
+            format: { targetType: getEntityName(target), value: getEntityName(source) },
             target: diagnosticTarget,
         });
     }
@@ -4516,22 +5868,6 @@ export function createChecker(program) {
 function isAnonymous(type) {
     return !("name" in type) || typeof type.name !== "string" || !type.name;
 }
-function isErrorType(type) {
-    return type.kind === "Intrinsic" && type.name === "ErrorType";
-}
-const numericRanges = {
-    int64: [BigInt("-9223372036854775807"), BigInt("9223372036854775808"), { int: true }],
-    int32: [-2147483648, 2147483647, { int: true }],
-    int16: [-32768, 32767, { int: true }],
-    int8: [-128, 127, { int: true }],
-    uint64: [0, BigInt("18446744073709551615"), { int: true }],
-    uint32: [0, 4294967295, { int: true }],
-    uint16: [0, 65535, { int: true }],
-    uint8: [0, 255, { int: true }],
-    safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER, { int: true }],
-    float32: [-3.4e38, 3.4e38, { int: false }],
-    float64: [-Number.MAX_VALUE, Number.MAX_VALUE, { int: false }],
-};
 /**
  * Find all named models that could have been the source of the given
  * property. This includes the named parents of all property sources in a
@@ -4831,7 +6167,7 @@ function reportDeprecation(program, target, message, reportFunc) {
 function applyDecoratorToType(program, decApp, target) {
     compilerAssert("decorators" in target, "Cannot apply decorator to non-decoratable type", target);
     for (const arg of decApp.args) {
-        if (isErrorType(arg.value)) {
+        if (isType(arg.value) && isErrorType(arg.value)) {
             // If one of the decorator argument is an error don't run it.
             return;
         }
@@ -4886,23 +6222,6 @@ function createDecoratorContext(program, decApp) {
         },
     };
 }
-/**
- * Convert TypeSpec argument to JS argument.
- */
-function marshalArgumentsForJS(args) {
-    return args.map((arg) => {
-        if (arg.kind === "Boolean" || arg.kind === "String" || arg.kind === "Number") {
-            return literalTypeToValue(arg);
-        }
-        else if (arg.kind === "StringTemplate") {
-            return stringTemplateToString(arg)[0];
-        }
-        return arg;
-    });
-}
-function literalTypeToValue(type) {
-    return type.value;
-}
 function isTemplatedNode(node) {
     return "templateParameters" in node && node.templateParameters.length > 0;
 }
@@ -4926,9 +6245,10 @@ const ReflectionNameToKind = {
 const _assertReflectionNameToKind = ReflectionNameToKind;
 var ResolutionKind;
 (function (ResolutionKind) {
-    ResolutionKind[ResolutionKind["Type"] = 0] = "Type";
-    ResolutionKind[ResolutionKind["BaseType"] = 1] = "BaseType";
-    ResolutionKind[ResolutionKind["Constraint"] = 2] = "Constraint";
+    ResolutionKind[ResolutionKind["Value"] = 0] = "Value";
+    ResolutionKind[ResolutionKind["Type"] = 1] = "Type";
+    ResolutionKind[ResolutionKind["BaseType"] = 2] = "BaseType";
+    ResolutionKind[ResolutionKind["Constraint"] = 3] = "Constraint";
 })(ResolutionKind || (ResolutionKind = {}));
 class PendingResolutions {
     #data = new Map();
@@ -4964,4 +6284,19 @@ const defaultSymbolResolutionOptions = {
     resolveDecorators: false,
     checkTemplateTypes: true,
 };
+/**
+ * Convert LEGACY for projection.
+ * THIS IS BROKEN. Some decorators will not receive the correct type.
+ * It has been broken since the introduction of valueof.
+ * As projection as put on hold as long as versioning works we are in a good state.
+ */
+function unsafe_projectionArgumentMarshalForJS(arg) {
+    if (arg.kind === "Boolean" || arg.kind === "String" || arg.kind === "Number") {
+        return arg.value;
+    }
+    else if (arg.kind === "StringTemplate") {
+        return arg.stringValue;
+    }
+    return arg;
+}
 //# sourceMappingURL=checker.js.map