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

package/dist/src/core/checker.js

@@ -19,6 +19,106 @@ import { exprIsBareIdentifier, getFirstAncestor, getIdentifierContext, hasParseE
 import { createTypeRelationChecker } from "./type-relation-checker.js";
 import { getFullyQualifiedSymbolName, getParentTemplateNode, isArrayModelType, isErrorType, isNullType, isTemplateInstance, isType, isValue, } from "./type-utils.js";
 import { IdentifierKind, ResolutionResultFlags, SyntaxKind, } from "./types.js";
+var CheckFlags;
+(function (CheckFlags) {
+    /** No flags set. */
+    CheckFlags[CheckFlags["None"] = 0] = "None";
+    /** Currently checking within an uninstantiated template declaration. */
+    CheckFlags[CheckFlags["InTemplateDeclaration"] = 1] = "InTemplateDeclaration";
+})(CheckFlags || (CheckFlags = {}));
+class CheckContext {
+    /** The type mapper associated with this context, if any. */
+    mapper;
+    /** The flags enabled in this context. */
+    flags;
+    #templateParametersObserved;
+    static from(contextOrMapper) {
+        if (contextOrMapper instanceof CheckContext) {
+            return contextOrMapper;
+        }
+        return new CheckContext(contextOrMapper, CheckFlags.None);
+    }
+    /**
+     * The default CheckContext to use at API entrypoints.
+     */
+    static DEFAULT = new CheckContext(undefined, CheckFlags.None);
+    constructor(mapper, flags, templateParametersObserved) {
+        this.mapper = mapper;
+        this.flags = flags;
+        this.#templateParametersObserved = templateParametersObserved;
+        Object.freeze(this);
+    }
+    /**
+     * Returns a new context with the given flags _added_ to the existing flags.
+     *
+     * @param flags - the flags to enable
+     * @returns a new CheckContext with the given flags enabled.
+     */
+    withFlags(flags) {
+        return new CheckContext(this.mapper, this.flags | flags, this.#templateParametersObserved);
+    }
+    /**
+     * Returns a new context with the given flags disabled.
+     *
+     * @param flags - the flags to disable
+     * @returns a new CheckContext with the given flags disabled.
+     */
+    maskFlags(flags) {
+        return new CheckContext(this.mapper, this.flags & ~flags, this.#templateParametersObserved);
+    }
+    /**
+     * Returns true if ALL of the given flags are enabled in this context.
+     */
+    hasFlags(flags) {
+        return (this.flags & flags) === flags;
+    }
+    /**
+     * Returns a new context with the given mapper.
+     *
+     * @param mapper - the new type mapper, or undefined to clear the mapper
+     * @returns a new CheckContext with the given mapper.
+     */
+    withMapper(mapper) {
+        return new CheckContext(mapper, this.flags, this.#templateParametersObserved);
+    }
+    /**
+     * Observes a template parameter within the current observation scope, if any.
+     *
+     * @param param - the TemplateParameter type instance to observe
+     */
+    observeTemplateParameter(param) {
+        this.#templateParametersObserved?.add(param);
+    }
+    /**
+     * Returns a new CheckContext with a new (empty) template parameter observation scope.
+     *
+     * Call this when you need to observe template parameters used within a specific context.
+     *
+     * @returns a new CheckContext with an empty template parameter observation scope.
+     */
+    enterTemplateObserverScope() {
+        return new CheckContext(this.mapper, this.flags, new Set());
+    }
+    /**
+     * Creates a new CheckContext with no template parameter observation enabled.
+     *
+     * Call this when the checker is moving from one declaration to another, where usage of template parameters
+     * from the next scope should not impact the usage from the previous scope.
+     *
+     * @returns a new CheckContext with no template parameter observation.
+     */
+    exitTemplateObserverScope() {
+        return new CheckContext(this.mapper, this.flags, undefined);
+    }
+    /**
+     * @returns true if the observer scope in this context has seen any template parameter usage.
+     */
+    hasObservedTemplateParameters() {
+        return this.#templateParametersObserved !== undefined
+            ? this.#templateParametersObserved.size > 0
+            : false;
+    }
+}
 /**
  * Maps type arguments to type instantiation.
  */
@@ -140,10 +240,10 @@ export function createChecker(program, resolver) {
         const sym = typespecNamespaceBinding?.exports?.get(name);
         compilerAssert(sym, `Unexpected missing symbol to std type "${name}"`);
         if (sym.flags & 2 /* SymbolFlags.Model */) {
-            checkModelStatement(sym.declarations[0], undefined);
+            checkModelStatement(CheckContext.DEFAULT, sym.declarations[0]);
         }
         else {
-            checkScalar(sym.declarations[0], undefined);
+            checkScalar(CheckContext.DEFAULT, sym.declarations[0]);
         }
         const loadedType = stdTypes[name];
         compilerAssert(loadedType, `TypeSpec std type "${name}" should have been initalized before using array syntax.`);
@@ -157,17 +257,17 @@ export function createChecker(program, resolver) {
      * @param type Type
      * @param mapper Type mapper if in an template instantiation
      */
-    function linkType(links, type, mapper) {
-        if (mapper === undefined) {
+    function linkType(ctx, links, type) {
+        if (ctx.mapper === undefined) {
             links.declaredType = type;
             links.instantiations = new TypeInstantiationMap();
         }
         else if (links.instantiations) {
-            links.instantiations.set(mapper.args, type);
+            links.instantiations.set(ctx.mapper.args, type);
         }
     }
-    function linkMemberType(links, type, mapper) {
-        if (mapper === undefined) {
+    function linkMemberType(ctx, links, type) {
+        if (ctx.mapper === undefined) {
             links.declaredType = type;
         }
     }
@@ -177,15 +277,15 @@ export function createChecker(program, resolver) {
      * @param mapper Type mapper.
      * @returns Checked type for the given member symbol.
      */
-    function checkMemberSym(sym, mapper) {
+    function checkMemberSym(ctx, sym) {
         const symbolLinks = getSymbolLinks(sym);
-        const memberContainer = getTypeForNode(getSymNode(sym.parent), mapper);
+        const memberContainer = getTypeForNode(getSymNode(sym.parent), ctx);
         const type = symbolLinks.declaredType ?? symbolLinks.type;
         if (type) {
             return type;
         }
         else {
-            return checkMember(getSymNode(sym), mapper, memberContainer);
+            return checkMember(ctx, getSymNode(sym), memberContainer);
         }
     }
     /**
@@ -195,18 +295,18 @@ export function createChecker(program, resolver) {
      * @param containerType Member node container type(Interface, Model, Union, etc.)
      * @returns Checked member
      */
-    function checkMember(node, mapper, containerType) {
+    function checkMember(ctx, node, containerType) {
         switch (node.kind) {
             case SyntaxKind.ModelProperty:
-                return checkModelProperty(node, mapper);
+                return checkModelProperty(ctx, node);
             case SyntaxKind.EnumMember:
-                return checkEnumMember(node, mapper, containerType);
+                return checkEnumMember(ctx, node, containerType);
             case SyntaxKind.OperationStatement:
-                return checkOperation(node, mapper, containerType);
+                return checkOperation(ctx, node, containerType);
             case SyntaxKind.UnionVariant:
-                return checkUnionVariant(node, mapper);
+                return checkUnionVariant(ctx, node);
             case SyntaxKind.ScalarConstructor:
-                return checkScalarConstructor(node, mapper, containerType);
+                return checkScalarConstructor(ctx, node, containerType);
         }
     }
     function getTypeForTypeOrIndeterminate(entity) {
@@ -215,8 +315,9 @@ export function createChecker(program, resolver) {
         }
         return entity;
     }
-    function getTypeForNode(node, mapper) {
-        const entity = checkNode(node, mapper);
+    function getTypeForNode(node, mapperOrContext) {
+        const ctx = CheckContext.from(mapperOrContext);
+        const entity = checkNode(ctx, node);
         if (entity === null) {
             return errorType;
         }
@@ -242,8 +343,9 @@ export function createChecker(program, resolver) {
         }
         return entity;
     }
-    function getValueForNode(node, mapper, constraint) {
-        const initial = checkNode(node, mapper, constraint);
+    function getValueForNode(node, mapperOrContext, constraint) {
+        const ctx = CheckContext.from(mapperOrContext);
+        const initial = checkNode(ctx, node, constraint);
         if (initial === null) {
             return null;
         }
@@ -264,7 +366,9 @@ export function createChecker(program, resolver) {
         if (entity.kind === "TemplateParameter" &&
             entity.constraint?.valueType &&
             entity.constraint.type === undefined &&
-            mapper === undefined) {
+            ctx.mapper === undefined) {
+            // We must also observe that the template parameter is used here.
+            // ctx.observeTemplateParameter(entity);
             return createValue({
                 entityKind: "Value",
                 valueKind: "TemplateValue",
@@ -374,8 +478,9 @@ export function createChecker(program, resolver) {
      * This means that if the constraint is `string | valueof string` passing `"abc"` will send the value `"abc"` and not the type `"abc"`.
      */
     function getTypeOrValueForNode(node, mapper, constraint) {
+        const ctx = CheckContext.from(mapper);
         const valueConstraint = extractValueOfConstraints(constraint);
-        const entity = checkNode(node, mapper, valueConstraint);
+        const entity = checkNode(ctx, node, valueConstraint);
         if (entity === null) {
             return entity;
         }
@@ -419,33 +524,33 @@ export function createChecker(program, resolver) {
      * 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) {
+    function checkNode(ctx, node, valueConstraint) {
         switch (node.kind) {
             case SyntaxKind.ModelExpression:
-                return checkModel(node, mapper);
+                return checkModel(ctx, node);
             case SyntaxKind.ModelStatement:
-                return checkModel(node, mapper);
+                return checkModel(ctx, node);
             case SyntaxKind.ModelProperty:
-                return checkModelProperty(node, mapper);
+                return checkModelProperty(ctx, node);
             case SyntaxKind.ScalarStatement:
-                return checkScalar(node, mapper);
+                return checkScalar(ctx, node);
             case SyntaxKind.AliasStatement:
-                return checkAlias(node, mapper);
+                return checkAlias(ctx, node);
             case SyntaxKind.EnumStatement:
-                return checkEnum(node, mapper);
+                return checkEnum(ctx, node);
             case SyntaxKind.EnumMember:
-                return checkEnumMember(node, mapper);
+                return checkEnumMember(ctx, node);
             case SyntaxKind.InterfaceStatement:
-                return checkInterface(node, mapper);
+                return checkInterface(ctx, node);
             case SyntaxKind.UnionStatement:
-                return checkUnion(node, mapper);
+                return checkUnion(ctx, node);
             case SyntaxKind.UnionVariant:
-                return checkUnionVariant(node, mapper);
+                return checkUnionVariant(ctx, node);
             case SyntaxKind.NamespaceStatement:
             case SyntaxKind.JsNamespaceDeclaration:
-                return checkNamespace(node);
+                return checkNamespace(ctx, node);
             case SyntaxKind.OperationStatement:
-                return checkOperation(node, mapper);
+                return checkOperation(ctx, node);
             case SyntaxKind.NumericLiteral:
                 return checkNumericLiteral(node);
             case SyntaxKind.BooleanLiteral:
@@ -453,25 +558,25 @@ export function createChecker(program, resolver) {
             case SyntaxKind.StringLiteral:
                 return checkStringLiteral(node);
             case SyntaxKind.TupleExpression:
-                return checkTupleExpression(node, mapper);
+                return checkTupleExpression(ctx, node);
             case SyntaxKind.StringTemplateExpression:
-                return checkStringTemplateExpresion(node, mapper);
+                return checkStringTemplateExpresion(ctx, node);
             case SyntaxKind.ArrayExpression:
-                return checkArrayExpression(node, mapper);
+                return checkArrayExpression(ctx, node);
             case SyntaxKind.UnionExpression:
-                return checkUnionExpression(node, mapper);
+                return checkUnionExpression(ctx, node);
             case SyntaxKind.IntersectionExpression:
-                return checkIntersectionExpression(node, mapper);
+                return checkIntersectionExpression(ctx, node);
             case SyntaxKind.DecoratorDeclarationStatement:
-                return checkDecoratorDeclaration(node, mapper);
+                return checkDecoratorDeclaration(ctx, node);
             case SyntaxKind.FunctionDeclarationStatement:
-                return checkFunctionDeclaration(node, mapper);
+                return checkFunctionDeclaration(ctx, node);
             case SyntaxKind.TypeReference:
-                return checkTypeOrValueReference(node, mapper);
+                return checkTypeOrValueReference(ctx, node);
             case SyntaxKind.TemplateArgument:
-                return checkTemplateArgument(node, mapper);
+                return checkTemplateArgument(ctx, node);
             case SyntaxKind.TemplateParameterDeclaration:
-                return checkTemplateParameterDeclaration(node, mapper);
+                return checkTemplateParameterDeclaration(ctx, node);
             case SyntaxKind.VoidKeyword:
                 return voidType;
             case SyntaxKind.NeverKeyword:
@@ -479,19 +584,19 @@ export function createChecker(program, resolver) {
             case SyntaxKind.UnknownKeyword:
                 return unknownType;
             case SyntaxKind.ObjectLiteral:
-                return checkObjectValue(node, mapper, valueConstraint);
+                return checkObjectValue(ctx, node, valueConstraint);
             case SyntaxKind.ArrayLiteral:
-                return checkArrayValue(node, mapper, valueConstraint);
+                return checkArrayValue(ctx, node, valueConstraint);
             case SyntaxKind.ConstStatement:
                 return checkConst(node);
             case SyntaxKind.CallExpression:
-                return checkCallExpression(node, mapper);
+                return checkCallExpression(ctx, node);
             case SyntaxKind.TypeOfExpression:
-                return checkTypeOfExpression(node, mapper);
+                return checkTypeOfExpression(ctx, node);
             case SyntaxKind.AugmentDecoratorStatement:
-                return checkAugmentDecorator(node);
+                return checkAugmentDecorator(ctx, node);
             case SyntaxKind.UsingStatement:
-                return checkUsings(node);
+                return checkUsings(ctx, node);
             default:
                 return errorType;
         }
@@ -518,7 +623,7 @@ export function createChecker(program, resolver) {
     function isInTypeSpecNamespace(type) {
         return Boolean(type.namespace && isTypeSpecNamespace(type.namespace));
     }
-    function checkTemplateParameterDeclaration(node, mapper) {
+    function checkTemplateParameterDeclaration(ctx, node) {
         const parentNode = node.parent;
         const grandParentNode = parentNode.parent;
         const links = getSymbolLinks(node.symbol);
@@ -526,7 +631,7 @@ export function createChecker(program, resolver) {
             templateParameterUsageMap.set(node, false);
         }
         if (pendingResolutions.has(getNodeSym(node), ResolutionKind.Constraint)) {
-            if (mapper === undefined) {
+            if (ctx.mapper === undefined) {
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "circular-constraint",
                     format: { typeName: node.id.sv },
@@ -553,18 +658,18 @@ export function createChecker(program, resolver) {
             });
             if (node.constraint) {
                 pendingResolutions.start(getNodeSym(node), ResolutionKind.Constraint);
-                type.constraint = getParamConstraintEntityForNode(node.constraint);
+                type.constraint = getParamConstraintEntityForNode(ctx, node.constraint);
                 pendingResolutions.finish(getNodeSym(node), ResolutionKind.Constraint);
             }
             if (node.default) {
                 // Set this to unknownType in case the default points back to the template itself causing failures
                 type.default = unknownType;
-                type.default = checkTemplateParameterDefault(node.default, parentNode.templateParameters, index, type.constraint);
+                type.default = checkTemplateParameterDefault(ctx, node.default, parentNode.templateParameters, index, type.constraint);
             }
         }
-        return mapper ? mapper.getMappedType(type) : type;
+        return ctx.mapper ? ctx.mapper.getMappedType(type) : type;
     }
-    function getResolvedTypeParameterDefault(declaredType, node, mapper) {
+    function getResolvedTypeParameterDefault(ctx, declaredType, node) {
         if (declaredType.default === undefined) {
             return undefined;
         }
@@ -572,11 +677,11 @@ export function createChecker(program, resolver) {
             declaredType.default === null) {
             return declaredType.default;
         }
-        return checkNode(node.default, mapper);
+        return checkNode(ctx, node.default);
     }
-    function checkTemplateParameterDefault(nodeDefault, templateParameters, index, constraint) {
+    function checkTemplateParameterDefault(ctx, nodeDefault, templateParameters, index, constraint) {
         function visit(node) {
-            const entity = checkNode(node);
+            const entity = checkNode(ctx, node);
             let hasError = false;
             if (entity !== null && "kind" in entity && entity.kind === "TemplateParameter") {
                 for (let i = index; i < templateParameters.length; i++) {
@@ -608,12 +713,12 @@ export function createChecker(program, resolver) {
      * @param instantiateTemplate If templated type should be instantiated if they haven't yet.
      * @returns Resolved type.
      */
-    function checkTypeReference(node, mapper, instantiateTemplate = true) {
-        const sym = resolveTypeReferenceSym(node, mapper);
+    function checkTypeReference(ctx, node, instantiateTemplate = true) {
+        const sym = resolveTypeReferenceSym(ctx, node);
         if (!sym) {
             return errorType;
         }
-        const type = checkTypeReferenceSymbol(sym, node, mapper, instantiateTemplate);
+        const type = checkTypeReferenceSymbol(ctx, sym, node, instantiateTemplate);
         return type;
     }
     /**
@@ -623,21 +728,21 @@ export function createChecker(program, resolver) {
      * @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);
+    function checkTypeOrValueReference(ctx, node, instantiateTemplate = true) {
+        const sym = resolveTypeReferenceSym(ctx, node);
         if (!sym) {
             return errorType;
         }
-        return checkTypeOrValueReferenceSymbol(sym, node, mapper, instantiateTemplate) ?? errorType;
+        return checkTypeOrValueReferenceSymbol(ctx, sym, node, instantiateTemplate) ?? errorType;
     }
-    function checkTemplateArgument(node, mapper) {
-        return checkNode(node.argument, mapper);
+    function checkTemplateArgument(ctx, node) {
+        return checkNode(ctx, node.argument);
     }
     function resolveTypeOrValueReference(node) {
         const oldDiagnosticHook = onCheckerDiagnostic;
         const diagnostics = [];
         onCheckerDiagnostic = (x) => diagnostics.push(x);
-        const entity = checkTypeOrValueReference(node, undefined, false);
+        const entity = checkTypeOrValueReference(CheckContext.DEFAULT, node, false);
         onCheckerDiagnostic = oldDiagnosticHook;
         return [entity === errorType ? undefined : entity, diagnostics];
     }
@@ -645,7 +750,7 @@ export function createChecker(program, resolver) {
         const oldDiagnosticHook = onCheckerDiagnostic;
         const diagnostics = [];
         onCheckerDiagnostic = (x) => diagnostics.push(x);
-        const type = checkTypeReference(node, undefined, false);
+        const type = checkTypeReference(CheckContext.DEFAULT, node, false);
         onCheckerDiagnostic = oldDiagnosticHook;
         return [type === errorType ? undefined : type, diagnostics];
     }
@@ -702,11 +807,11 @@ export function createChecker(program, resolver) {
                 return false;
         }
     }
-    function checkTemplateInstantiationArgs(node, args, decls, mapper, parentMapper) {
+    function checkTemplateInstantiationArgs(ctx, node, args, decls, parentMapper) {
         const params = new Map();
         const positional = [];
         const initMap = new Map(decls.map((decl) => {
-            const declaredType = checkTemplateParameterDeclaration(decl, undefined);
+            const declaredType = checkTemplateParameterDeclaration(CheckContext.DEFAULT, decl);
             positional.push(declaredType);
             params.set(decl.id.sv, declaredType);
             return [
@@ -720,7 +825,7 @@ export function createChecker(program, resolver) {
         let named = false;
         for (const [arg, idx] of args.map((v, i) => [v, i])) {
             function deferredCheck() {
-                return [arg, checkNode(arg.argument, mapper)];
+                return [arg, checkNode(ctx, arg.argument)];
             }
             if (arg.name) {
                 named = true;
@@ -780,8 +885,8 @@ export function createChecker(program, resolver) {
                 mapperArgs.push(type);
             }
             if (init === null) {
-                const argumentMapper = createTypeMapper(mapperParams, mapperArgs, { node, mapper }, parentMapper);
-                const defaultValue = getResolvedTypeParameterDefault(param, decl, argumentMapper);
+                const argumentMapper = createTypeMapper(mapperParams, mapperArgs, { node, mapper: ctx.mapper }, parentMapper);
+                const defaultValue = getResolvedTypeParameterDefault(ctx.withMapper(argumentMapper), param, decl);
                 if (defaultValue) {
                     commit(param, defaultValue);
                 }
@@ -850,8 +955,8 @@ export function createChecker(program, resolver) {
      * @param instantiateTemplates If a templated type should be instantiated if not yet @default true
      * @returns resolved type.
      */
-    function checkTypeReferenceSymbol(sym, node, mapper, instantiateTemplates = true) {
-        const result = checkTypeOrValueReferenceSymbol(sym, node, mapper, instantiateTemplates);
+    function checkTypeReferenceSymbol(ctx, sym, node, instantiateTemplates = true) {
+        const result = checkTypeOrValueReferenceSymbol(ctx, sym, node, instantiateTemplates);
         if (result === null || isValue(result)) {
             reportCheckerDiagnostic(createDiagnostic({ code: "value-in-type", target: node }));
             return errorType;
@@ -861,16 +966,17 @@ export function createChecker(program, resolver) {
         }
         return result;
     }
-    function checkTypeOrValueReferenceSymbol(sym, node, mapper, instantiateTemplates = true) {
-        const entity = checkTypeOrValueReferenceSymbolWorker(sym, node, mapper, instantiateTemplates);
+    function checkTypeOrValueReferenceSymbol(ctx, sym, node, instantiateTemplates = true) {
+        const entity = checkTypeOrValueReferenceSymbolWorker(ctx, sym, node, instantiateTemplates);
         if (entity !== null && isType(entity) && entity.kind === "TemplateParameter") {
+            ctx.observeTemplateParameter(entity);
             templateParameterUsageMap.set(entity.node, true);
         }
         return entity;
     }
-    function checkTypeOrValueReferenceSymbolWorker(sym, node, mapper, instantiateTemplates = true) {
+    function checkTypeOrValueReferenceSymbolWorker(ctx, sym, node, instantiateTemplates = true) {
         if (sym.flags & 131072 /* SymbolFlags.Const */) {
-            return getValueForNode(sym.declarations[0], mapper);
+            return getValueForNode(sym.declarations[0], ctx.mapper);
         }
         if (sym.flags & 512 /* SymbolFlags.Decorator */) {
             reportCheckerDiagnostic(createDiagnostic({ code: "invalid-type-ref", messageId: "decorator", target: sym }));
@@ -893,6 +999,12 @@ export function createChecker(program, resolver) {
                     64 /* SymbolFlags.Union */)) {
             const decl = sym.declarations[0];
             if (!isTemplatedNode(decl)) {
+                // Not a templated node, and we are moving through a typeref to a new declaration.
+                // Therefore, we are no longer in a template declaration if we were before, and we are
+                // visiting a new declaration, so we exit the active template observer scope, if any.
+                const innerCtx = ctx
+                    .maskFlags(CheckFlags.InTemplateDeclaration)
+                    .exitTemplateObserverScope();
                 if (argumentNodes.length > 0) {
                     reportCheckerDiagnostic(createDiagnostic({
                         code: "invalid-template-args",
@@ -908,17 +1020,26 @@ export function createChecker(program, resolver) {
                     baseType = symbolLinks.declaredType;
                 }
                 else if (sym.flags & 65536 /* SymbolFlags.Member */) {
-                    baseType = checkMemberSym(sym, mapper);
+                    baseType = checkMemberSym(innerCtx, sym);
                 }
                 else {
-                    baseType = checkDeclaredTypeOrIndeterminate(sym, decl, mapper);
+                    //
+                    baseType = checkDeclaredTypeOrIndeterminate(innerCtx, sym, decl);
                 }
             }
             else {
-                const declaredType = getOrCheckDeclaredType(sym, decl, mapper);
+                // Checking the declaration to ensure we have the template itself, so we don't need the mapper.
+                const declaredType = getOrCheckDeclaredType(ctx.withMapper(undefined), sym, decl);
                 const templateParameters = decl.templateParameters;
-                const instantiation = checkTemplateInstantiationArgs(node, argumentNodes, templateParameters, mapper, declaredType.templateMapper);
-                baseType = getOrInstantiateTemplate(decl, [...instantiation.keys()], [...instantiation.values()], { node, mapper }, declaredType.templateMapper, instantiateTemplates);
+                const instantiationArgsCtx = ctx.enterTemplateObserverScope();
+                const instantiation = checkTemplateInstantiationArgs(instantiationArgsCtx, node, argumentNodes, templateParameters, declaredType.templateMapper);
+                // If we didn't see any template parameters during argument checking, then this type reference is "pure"
+                // and we can mask the InTemplateDeclaration flag downstream. In either case, we are going to a new declaration
+                // so we exit the active template observer scope, if any.
+                const innerCtx = (instantiationArgsCtx.hasObservedTemplateParameters()
+                    ? ctx
+                    : ctx.maskFlags(CheckFlags.InTemplateDeclaration)).exitTemplateObserverScope();
+                baseType = getOrInstantiateTemplate(innerCtx, decl, [...instantiation.keys()], [...instantiation.values()], { node, mapper: ctx.mapper }, declaredType.templateMapper, instantiateTemplates);
             }
         }
         else {
@@ -936,7 +1057,7 @@ export function createChecker(program, resolver) {
                 return sym.type;
             }
             else if (sym.flags & 1024 /* SymbolFlags.TemplateParameter */) {
-                const mapped = checkTemplateParameterDeclaration(symNode, mapper);
+                const mapped = checkTemplateParameterDeclaration(ctx, symNode);
                 baseType = mapped;
             }
             else if (symbolLinks.type) {
@@ -948,11 +1069,11 @@ export function createChecker(program, resolver) {
             }
             else {
                 if (sym.flags & 65536 /* SymbolFlags.Member */) {
-                    baseType = checkMemberSym(sym, mapper);
+                    baseType = checkMemberSym(ctx, sym);
                 }
                 else {
                     // don't have a cached type for this symbol, so go grab it and cache it
-                    baseType = getTypeForNode(symNode, mapper);
+                    baseType = getTypeForNode(symNode, ctx);
                     symbolLinks.type = baseType;
                 }
             }
@@ -961,7 +1082,7 @@ export function createChecker(program, resolver) {
         // don't raise deprecation when the usage site is also a deprecated
         // declaration.
         const declarationNode = getSymNode(sym);
-        if (declarationNode && mapper === undefined && isType(baseType)) {
+        if (declarationNode && ctx.mapper === undefined && isType(baseType)) {
             if (!isTypeReferenceContextDeprecated(node.parent)) {
                 checkDeprecated(baseType, declarationNode, node);
             }
@@ -980,7 +1101,7 @@ export function createChecker(program, resolver) {
      * @param mapper Type mapper for template resolution
      * @returns The declared type for the given node.
      */
-    function getOrCheckDeclaredType(sym, decl, mapper) {
+    function getOrCheckDeclaredType(ctx, sym, decl) {
         const symbolLinks = getSymbolLinks(sym);
         if (symbolLinks.declaredType) {
             return symbolLinks.declaredType;
@@ -990,10 +1111,10 @@ export function createChecker(program, resolver) {
             return sym.type;
         }
         if (sym.flags & 65536 /* SymbolFlags.Member */) {
-            return checkMemberSym(sym, mapper);
+            return checkMemberSym(ctx, sym);
         }
         else {
-            return checkDeclaredType(sym, decl, mapper);
+            return checkDeclaredType(ctx, sym, decl);
         }
     }
     /**
@@ -1003,24 +1124,24 @@ export function createChecker(program, resolver) {
      * @param mapper Type mapper for template resolution
      * @returns The declared type for the given node.
      */
-    function checkDeclaredTypeOrIndeterminate(sym, node, mapper) {
+    function checkDeclaredTypeOrIndeterminate(ctx, sym, node) {
         const type = sym.flags & 2 /* SymbolFlags.Model */
-            ? checkModelStatement(node, mapper)
+            ? checkModelStatement(ctx, node)
             : sym.flags & 4 /* SymbolFlags.Scalar */
-                ? checkScalar(node, mapper)
+                ? checkScalar(ctx, node)
                 : sym.flags & 128 /* SymbolFlags.Alias */
-                    ? checkAlias(node, mapper)
+                    ? checkAlias(ctx, node)
                     : sym.flags & 32 /* SymbolFlags.Interface */
-                        ? checkInterface(node, mapper)
+                        ? checkInterface(ctx, node)
                         : sym.flags & 8 /* SymbolFlags.Operation */
-                            ? checkOperation(node, mapper)
-                            : checkUnion(node, mapper);
+                            ? checkOperation(ctx, node)
+                            : checkUnion(ctx, node);
         return type;
     }
-    function checkDeclaredType(sym, node, mapper) {
-        return getTypeForTypeOrIndeterminate(checkDeclaredTypeOrIndeterminate(sym, node, mapper));
+    function checkDeclaredType(ctx, sym, node) {
+        return getTypeForTypeOrIndeterminate(checkDeclaredTypeOrIndeterminate(ctx, sym, node));
     }
-    function getOrInstantiateTemplate(templateNode, params, args, source, parentMapper, instantiateTempalates = true) {
+    function getOrInstantiateTemplate(ctx, templateNode, params, args, source, parentMapper, instantiateTempalates = true) {
         const symbolLinks = templateNode.kind === SyntaxKind.OperationStatement &&
             templateNode.parent.kind === SyntaxKind.InterfaceStatement
             ? getSymbolLinksForMember(templateNode)
@@ -1041,7 +1162,7 @@ export function createChecker(program, resolver) {
             return cached;
         }
         if (instantiateTempalates) {
-            return instantiateTemplate(symbolLinks.instantiations, templateNode, params, mapper);
+            return instantiateTemplate(ctx.withMapper(mapper), symbolLinks.instantiations, templateNode, params);
         }
         else {
             return errorType;
@@ -1056,10 +1177,10 @@ export function createChecker(program, resolver) {
      * twice at the same time, or if template parameters from more than one template
      * are ever in scope at once.
      */
-    function instantiateTemplate(instantiations, templateNode, params, mapper) {
-        const type = getTypeForNode(templateNode, mapper);
-        if (!instantiations.get(mapper.args)) {
-            instantiations.set(mapper.args, type);
+    function instantiateTemplate(ctx, instantiations, templateNode, params) {
+        const type = getTypeForNode(templateNode, ctx);
+        if (!instantiations.get(ctx.mapper.args)) {
+            instantiations.set(ctx.mapper.args, type);
         }
         if (type.kind === "Model") {
             type.templateNode = templateNode;
@@ -1067,11 +1188,11 @@ export function createChecker(program, resolver) {
         return type;
     }
     /** Check a union expresion used in a parameter constraint, those allow the use of `valueof` as a variant. */
-    function checkMixedParameterConstraintUnion(node, mapper) {
+    function checkMixedParameterConstraintUnion(ctx, node) {
         const values = [];
         const types = [];
         for (const option of node.options) {
-            const [kind, type] = getTypeOrValueOfTypeForNode(option, mapper);
+            const [kind, type] = getTypeOrValueOfTypeForNode(ctx, option);
             if (kind === "value") {
                 values.push(type);
             }
@@ -1117,7 +1238,7 @@ export function createChecker(program, resolver) {
         }
         return union;
     }
-    function checkUnionExpression(node, mapper) {
+    function checkUnionExpression(ctx, node) {
         const unionType = createAndFinishType({
             kind: "Union",
             node,
@@ -1130,7 +1251,7 @@ export function createChecker(program, resolver) {
             decorators: [],
         });
         for (const o of node.options) {
-            const type = getTypeForNode(o, mapper);
+            const type = getTypeForNode(o, ctx);
             // The type `A | never` is just `A`
             if (type === neverType) {
                 continue;
@@ -1152,7 +1273,7 @@ export function createChecker(program, resolver) {
                 unionType.variants.set(variant.name, variant);
             }
         }
-        linkMapper(unionType, mapper);
+        linkMapper(unionType, ctx.mapper);
         return unionType;
     }
     /**
@@ -1160,17 +1281,17 @@ export function createChecker(program, resolver) {
      * So this doesn't work if we don't have a known set of properties (e.g.
      * with unions). The resulting model is anonymous.
      */
-    function checkIntersectionExpression(node, mapper) {
+    function checkIntersectionExpression(ctx, node) {
         const links = getSymbolLinks(node.symbol);
-        if (links.declaredType && mapper === undefined) {
+        if (links.declaredType && ctx.mapper === undefined) {
             // we're not instantiating this model and we've already checked it
             return links.declaredType;
         }
         const intersection = initModel(node);
-        const options = node.options.map((o) => [o, getTypeForNode(o, mapper)]);
+        const options = node.options.map((o) => [o, getTypeForNode(o, ctx)]);
         ensureResolved(options.map(([, type]) => type), intersection, () => {
-            const type = mergeModelTypes(node.symbol, node, options, mapper, intersection);
-            linkType(links, type, mapper);
+            const type = mergeModelTypes(ctx, node.symbol, node, options, intersection);
+            linkType(ctx, links, type);
             finishType(intersection);
         });
         return intersection;
@@ -1203,10 +1324,10 @@ export function createChecker(program, resolver) {
         }
         check();
     }
-    function checkDecoratorDeclaration(node, mapper) {
+    function checkDecoratorDeclaration(ctx, node) {
         const symbol = getMergedSymbol(node.symbol);
         const links = getSymbolLinks(symbol);
-        if (links.declaredType && mapper === undefined) {
+        if (links.declaredType && ctx.mapper === undefined) {
             // we're not instantiating this operation and we've already checked it
             return links.declaredType;
         }
@@ -1225,19 +1346,19 @@ export function createChecker(program, resolver) {
             name: `@${name}`,
             namespace,
             node,
-            target: checkFunctionParameter(node.target, mapper, true),
-            parameters: node.parameters.map((x) => checkFunctionParameter(x, mapper, true)),
+            target: checkFunctionParameter(ctx, node.target, true),
+            parameters: node.parameters.map((param) => checkFunctionParameter(ctx, param, true)),
             implementation: implementation ?? (() => { }),
         });
         namespace.decoratorDeclarations.set(name, decoratorType);
-        linkType(links, decoratorType, mapper);
+        linkType(ctx, links, decoratorType);
         return decoratorType;
     }
-    function checkFunctionDeclaration(node, mapper) {
+    function checkFunctionDeclaration(ctx, node) {
         reportCheckerDiagnostic(createDiagnostic({ code: "function-unsupported", target: node }));
         return errorType;
     }
-    function checkFunctionParameter(node, mapper, mixed) {
+    function checkFunctionParameter(ctx, node, mixed) {
         const links = getSymbolLinks(node.symbol);
         if (links.declaredType) {
             return links.declaredType;
@@ -1260,7 +1381,7 @@ export function createChecker(program, resolver) {
         let parameterType;
         if (mixed) {
             const type = node.type
-                ? getParamConstraintEntityForNode(node.type)
+                ? getParamConstraintEntityForNode(ctx, node.type)
                 : {
                     entityKind: "MixedParameterConstraint",
                     type: unknownType,
@@ -1280,24 +1401,24 @@ export function createChecker(program, resolver) {
                 implementation: node.symbol.value,
             });
         }
-        linkType(links, parameterType, mapper);
+        linkType(ctx, links, parameterType);
         return parameterType;
     }
-    function getTypeOrValueOfTypeForNode(node, mapper) {
+    function getTypeOrValueOfTypeForNode(ctx, node) {
         switch (node.kind) {
             case SyntaxKind.ValueOfExpression:
-                const target = getTypeForNode(node.target, mapper);
+                const target = getTypeForNode(node.target, ctx);
                 return ["value", target];
             default:
-                return ["type", getTypeForNode(node, mapper)];
+                return ["type", getTypeForNode(node, ctx)];
         }
     }
-    function getParamConstraintEntityForNode(node, mapper) {
+    function getParamConstraintEntityForNode(ctx, node) {
         switch (node.kind) {
             case SyntaxKind.UnionExpression:
-                return checkMixedParameterConstraintUnion(node, mapper);
+                return checkMixedParameterConstraintUnion(ctx, node);
             default:
-                const [kind, entity] = getTypeOrValueOfTypeForNode(node, mapper);
+                const [kind, entity] = getTypeOrValueOfTypeForNode(ctx, node);
                 return {
                     entityKind: "MixedParameterConstraint",
                     node: node,
@@ -1306,7 +1427,7 @@ export function createChecker(program, resolver) {
                 };
         }
     }
-    function mergeModelTypes(parentModelSym, node, options, mapper, intersection) {
+    function mergeModelTypes(ctx, parentModelSym, node, options, intersection) {
         const properties = intersection.properties;
         const indexers = [];
         const modelOptions = options.filter((entry) => {
@@ -1355,7 +1476,7 @@ export function createChecker(program, resolver) {
                     ? cloneTypeForSymbol(memberSym, prop, overrides)
                     : cloneType(prop, overrides);
                 properties.set(prop.name, newPropType);
-                linkIndirectMember(node, newPropType, mapper);
+                linkIndirectMember(ctx, node, newPropType);
                 for (const indexer of indexers.filter((x) => x !== option.indexer)) {
                     checkPropertyCompatibleWithIndexer(indexer, prop, node);
                 }
@@ -1367,20 +1488,24 @@ export function createChecker(program, resolver) {
         else if (indexers.length > 1) {
             intersection.indexer = {
                 key: indexers[0].key,
-                value: mergeModelTypes(undefined, node, indexers.map((x) => [x.value.node, x.value]), mapper, initModel(node)),
+                value: mergeModelTypes(ctx, undefined, node, indexers.map((x) => [x.value.node, x.value]), initModel(node)),
             };
         }
-        linkMapper(intersection, mapper);
+        linkMapper(intersection, ctx.mapper);
         return finishType(intersection);
     }
-    function checkArrayExpression(node, mapper) {
-        const elementType = getTypeForNode(node.elementType, mapper);
+    function checkArrayExpression(ctx, node) {
+        const elementCtx = ctx.enterTemplateObserverScope();
+        const elementType = getTypeForNode(node.elementType, elementCtx);
+        const instantiationCtx = elementCtx.hasObservedTemplateParameters()
+            ? ctx
+            : ctx.maskFlags(CheckFlags.InTemplateDeclaration);
         const arrayType = getStdType("Array");
         const arrayNode = arrayType.node;
         const param = getTypeForNode(arrayNode.templateParameters[0]);
-        return getOrInstantiateTemplate(arrayNode, [param], [elementType], { node, mapper }, undefined);
+        return getOrInstantiateTemplate(instantiationCtx, arrayNode, [param], [elementType], { node, mapper: ctx.mapper }, undefined);
     }
-    function checkNamespace(node) {
+    function checkNamespace(ctx, node) {
         const links = getSymbolLinks(getMergedSymbol(node.symbol));
         let type = links.type;
         if (!type) {
@@ -1388,10 +1513,10 @@ export function createChecker(program, resolver) {
         }
         if (node.kind === SyntaxKind.NamespaceStatement) {
             if (isArray(node.statements)) {
-                node.statements.forEach((x) => checkNode(x));
+                node.statements.forEach((x) => checkNode(ctx, x));
             }
             else if (node.statements) {
-                const subNs = checkNamespace(node.statements);
+                const subNs = checkNamespace(ctx, node.statements);
                 type.namespaces.set(subNs.name, subNs);
             }
         }
@@ -1426,7 +1551,7 @@ export function createChecker(program, resolver) {
                 // namespaces created from TypeSpec scripts don't have decorators
                 if (sourceNode.kind !== SyntaxKind.NamespaceStatement)
                     continue;
-                type.decorators = type.decorators.concat(checkDecorators(type, sourceNode, undefined));
+                type.decorators = type.decorators.concat(checkDecorators(CheckContext.DEFAULT, type, sourceNode));
             }
             finishType(type);
             namespace?.namespaces.set(name, type);
@@ -1484,23 +1609,26 @@ export function createChecker(program, resolver) {
         }
         return symbolLinks.type;
     }
-    function checkOperation(node, mapper, parentInterface) {
+    function checkOperation(ctx, node, parentInterface) {
         const inInterface = node.parent?.kind === SyntaxKind.InterfaceStatement;
         const symbol = inInterface ? getSymbolForMember(node) : node.symbol;
         const links = symbol && getSymbolLinks(symbol);
         if (links) {
-            if (links.declaredType && mapper === undefined) {
+            if (links.declaredType && ctx.mapper === undefined) {
                 // we're not instantiating this operation and we've already checked it
                 return links.declaredType;
             }
         }
-        if (mapper === undefined && inInterface) {
+        if (ctx.mapper === undefined && inInterface) {
             compilerAssert(parentInterface, "Operation in interface should already have been checked.", node.parent);
         }
-        checkTemplateDeclaration(node, mapper);
+        checkTemplateDeclaration(ctx, node);
         // If we are instantating operation inside of interface
-        if (isTemplatedNode(node) && mapper !== undefined && parentInterface) {
-            mapper = { ...mapper, partial: true };
+        if (isTemplatedNode(node) && ctx.mapper !== undefined && parentInterface) {
+            ctx = ctx.withMapper({ ...ctx.mapper, partial: true });
+        }
+        if ((ctx.mapper === undefined || ctx.mapper.partial) && node.templateParameters.length > 0) {
+            ctx = ctx.withFlags(CheckFlags.InTemplateDeclaration);
         }
         const namespace = getParentNamespaceType(node);
         const name = node.id.sv;
@@ -1526,21 +1654,20 @@ export function createChecker(program, resolver) {
             interface: parentInterface,
         });
         if (links) {
-            linkType(links, operationType, mapper);
+            linkType(ctx, links, operationType);
         }
         const parent = node.parent;
         function finishOperation() {
             operationType.parameters.namespace = namespace;
-            operationType.decorators.push(...checkDecorators(operationType, node, mapper));
-            const runDecorators = parent.kind === SyntaxKind.InterfaceStatement
-                ? shouldRunDecorators(parent, mapper) && shouldRunDecorators(node, mapper)
-                : shouldRunDecorators(node, mapper);
-            return finishType(operationType, { skipDecorators: !runDecorators });
+            operationType.decorators.push(...checkDecorators(ctx, operationType, node));
+            return finishType(operationType, {
+                skipDecorators: ctx.hasFlags(CheckFlags.InTemplateDeclaration),
+            });
         }
         // Is this a definition or reference?
         if (node.signature.kind === SyntaxKind.OperationSignatureReference) {
             // Attempt to resolve the operation
-            const baseOperation = checkOperationIs(node, node.signature.baseOperation, mapper);
+            const baseOperation = checkOperationIs(ctx, node, node.signature.baseOperation);
             if (baseOperation) {
                 ensureResolved([baseOperation], operationType, () => {
                     operationType.sourceOperation = baseOperation;
@@ -1570,19 +1697,19 @@ export function createChecker(program, resolver) {
             }
         }
         else {
-            operationType.parameters = getTypeForNode(node.signature.parameters, mapper);
-            operationType.returnType = getTypeForNode(node.signature.returnType, mapper);
+            operationType.parameters = getTypeForNode(node.signature.parameters, ctx);
+            operationType.returnType = getTypeForNode(node.signature.returnType, ctx);
             ensureResolved([operationType.parameters], operationType, () => {
                 finishOperation();
             });
         }
-        linkMapper(operationType, mapper);
-        if (parent.kind !== SyntaxKind.InterfaceStatement && mapper === undefined) {
+        linkMapper(operationType, ctx.mapper);
+        if (parent.kind !== SyntaxKind.InterfaceStatement && ctx.mapper === undefined) {
             namespace?.operations.set(name, operationType);
         }
         return operationType;
     }
-    function checkOperationIs(operation, opReference, mapper) {
+    function checkOperationIs(ctx, operation, opReference) {
         if (!opReference)
             return undefined;
         // Ensure that we don't end up with a circular reference to the same operation
@@ -1593,7 +1720,7 @@ export function createChecker(program, resolver) {
         const target = resolver.getNodeLinks(opReference).resolvedSymbol;
         // Did we encounter a circular operation reference?
         if (target && pendingResolutions.has(target, ResolutionKind.BaseType)) {
-            if (mapper === undefined) {
+            if (ctx.mapper === undefined) {
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "circular-op-signature",
                     format: { typeName: target.name },
@@ -1603,7 +1730,7 @@ export function createChecker(program, resolver) {
             return undefined;
         }
         // Resolve the base operation type
-        const baseOperation = getTypeForNode(opReference, mapper);
+        const baseOperation = getTypeForNode(opReference, ctx);
         if (opSymId) {
             pendingResolutions.finish(opSymId, ResolutionKind.BaseType);
         }
@@ -1623,17 +1750,18 @@ export function createChecker(program, resolver) {
     function getGlobalNamespaceNode() {
         return resolver.symbols.global.declarations[0];
     }
-    function checkTupleExpression(node, mapper) {
+    function checkTupleExpression(ctx, node) {
         return createAndFinishType({
             kind: "Tuple",
             node: node,
-            values: node.values.map((v) => getTypeForNode(v, mapper)),
+            values: node.values.map((v) => getTypeForNode(v, ctx)),
         });
     }
     function getSymbolLinks(s) {
         return resolver.getSymbolLinks(s);
     }
     function resolveRelatedSymbols(id, mapper) {
+        const ctx = CheckContext.from(mapper);
         let sym;
         const { node, kind } = getIdentifierContext(id);
         switch (kind) {
@@ -1666,10 +1794,10 @@ export function createChecker(program, resolver) {
                         resolveDecorator = false;
                     }
                 }
-                sym = resolveTypeReferenceSym(ref, mapper, resolveDecorator);
+                sym = resolveTypeReferenceSym(ctx, ref, resolveDecorator);
                 break;
             case IdentifierKind.TemplateArgument:
-                const templates = getTemplateDeclarationsForArgument(node, mapper);
+                const templates = getTemplateDeclarationsForArgument(ctx, node);
                 const firstMatchingParameter = templates
                     .flatMap((t) => t.templateParameters)
                     .find((p) => p.id.sv === id.sv);
@@ -1691,14 +1819,14 @@ export function createChecker(program, resolver) {
         }
         return undefined; //sym?.symbolSource ?? sym;
     }
-    function getTemplateDeclarationsForArgument(node, mapper) {
+    function getTemplateDeclarationsForArgument(ctx, node) {
         const ref = node.parent;
-        let resolved = resolveTypeReferenceSym(ref, mapper, false);
+        let resolved = resolveTypeReferenceSym(ctx, ref, false);
         // if the reference type can't be resolved and has parse error,
         // it likely means the reference type hasn't been completed yet. i.e. Foo<string,
         // so try to resolve it by it's target directly to see if we can find its sym
         if (!resolved && hasParseError(ref) && ref.target !== undefined) {
-            resolved = resolveTypeReferenceSym(ref.target, mapper, false);
+            resolved = resolveTypeReferenceSym(ctx, ref.target, false);
         }
         return (resolved?.declarations.filter((n) => isTemplatedNode(n)) ?? []);
     }
@@ -1819,9 +1947,9 @@ export function createChecker(program, resolver) {
                 node?.parent?.parent?.kind === SyntaxKind.TypeReference) {
                 const argNode = node.parent;
                 const refNode = node.parent.parent;
-                const decl = getTemplateDeclarationsForArgument(argNode, 
+                const decl = getTemplateDeclarationsForArgument(
                 // We should be giving the argument so the mapper here should be undefined
-                undefined /* mapper */);
+                CheckContext.DEFAULT, argNode);
                 const index = refNode.arguments.findIndex((n) => n === argNode);
                 if (decl.length > 0 && decl[0].templateParameters.length > index) {
                     templateParmaeterDeclNode = decl[0].templateParameters[index];
@@ -1850,7 +1978,7 @@ export function createChecker(program, resolver) {
             if (callExpNode?.kind !== SyntaxKind.CallExpression) {
                 return undefined;
             }
-            const ctorType = checkCallExpressionTarget(callExpNode, undefined);
+            const ctorType = checkCallExpressionTarget(CheckContext.DEFAULT, callExpNode);
             if (ctorType?.kind !== "ScalarConstructor") {
                 return undefined;
             }
@@ -1921,7 +2049,7 @@ export function createChecker(program, resolver) {
             case IdentifierKind.Declaration:
                 return completions; // cannot complete, name can be chosen arbitrarily
             case IdentifierKind.TemplateArgument: {
-                const templates = getTemplateDeclarationsForArgument(ancestor, undefined);
+                const templates = getTemplateDeclarationsForArgument(CheckContext.DEFAULT, ancestor);
                 for (const template of templates) {
                     for (const param of template.templateParameters) {
                         addCompletion(param.id.sv, param.symbol);
@@ -1975,7 +2103,7 @@ export function createChecker(program, resolver) {
             let base = resolver.getNodeLinks(identifier.parent.base).resolvedSymbol;
             if (base) {
                 if (base.flags & 128 /* SymbolFlags.Alias */) {
-                    base = getAliasedSymbol(base, undefined);
+                    base = getAliasedSymbol(CheckContext.DEFAULT, base);
                 }
                 if (base) {
                     if (identifier.parent.selector === "::") {
@@ -2007,7 +2135,7 @@ export function createChecker(program, resolver) {
                 exprIsBareIdentifier(ancestor) &&
                 ancestor.parent?.kind === SyntaxKind.TemplateArgument &&
                 ancestor.parent.name === undefined) {
-                const templates = getTemplateDeclarationsForArgument(ancestor.parent, undefined);
+                const templates = getTemplateDeclarationsForArgument(CheckContext.DEFAULT, ancestor.parent);
                 for (const template of templates) {
                     for (const param of template.templateParameters) {
                         addCompletion(param.id.sv, param.symbol, { suffix: " = " });
@@ -2102,34 +2230,34 @@ export function createChecker(program, resolver) {
                 return undefined;
         }
     }
-    function resolveTypeReferenceSym(node, mapper, options) {
+    function resolveTypeReferenceSym(ctx, node, options) {
         const resolvedOptions = typeof options === "boolean"
             ? { ...defaultSymbolResolutionOptions, resolveDecorators: options }
             : { ...defaultSymbolResolutionOptions, ...(options ?? {}) };
-        if (mapper === undefined &&
+        if (ctx.mapper === undefined &&
             !resolvedOptions.resolveDeclarationOfTemplate &&
             referenceSymCache.has(node)) {
             return referenceSymCache.get(node);
         }
-        const sym = resolveTypeReferenceSymInternal(node, mapper, resolvedOptions);
+        const sym = resolveTypeReferenceSymInternal(ctx, node, resolvedOptions);
         if (!resolvedOptions.resolveDeclarationOfTemplate) {
             referenceSymCache.set(node, sym);
         }
         return sym;
     }
-    function resolveTypeReferenceSymInternal(node, mapper, options) {
+    function resolveTypeReferenceSymInternal(ctx, node, options) {
         if (hasParseError(node)) {
             // Don't report synthetic identifiers used for parser error recovery.
             // The parse error is the root cause and will already have been logged.
             return undefined;
         }
         if (node.kind === SyntaxKind.TypeReference) {
-            return resolveTypeReferenceSym(node.target, mapper, options);
+            return resolveTypeReferenceSym(ctx, node.target, options);
         }
         else if (node.kind === SyntaxKind.Identifier) {
             const links = resolver.getNodeLinks(node);
-            if (mapper === undefined && links.resolutionResult) {
-                if (mapper === undefined && // do not report error when instantiating
+            if (ctx.mapper === undefined && links.resolutionResult) {
+                if (ctx.mapper === undefined && // do not report error when instantiating
                     links.resolutionResult & (ResolutionResultFlags.NotFound | ResolutionResultFlags.Unknown)) {
                     reportCheckerDiagnostic(createDiagnostic({
                         code: "invalid-ref",
@@ -2147,7 +2275,7 @@ export function createChecker(program, resolver) {
             return sym?.symbolSource ?? sym;
         }
         else if (node.kind === SyntaxKind.MemberExpression) {
-            let base = resolveTypeReferenceSym(node.base, mapper, {
+            let base = resolveTypeReferenceSym(ctx, node.base, {
                 ...options,
                 resolveDecorators: false, // when resolving decorator the base cannot also be one
             });
@@ -2156,7 +2284,7 @@ export function createChecker(program, resolver) {
             }
             // when resolving a type reference based on an alias, unwrap the alias.
             if (base.flags & 128 /* SymbolFlags.Alias */) {
-                const aliasedSym = getAliasedSymbol(base, mapper);
+                const aliasedSym = getAliasedSymbol(ctx, base);
                 if (!aliasedSym) {
                     reportCheckerDiagnostic(createDiagnostic({
                         code: "invalid-ref",
@@ -2174,7 +2302,7 @@ export function createChecker(program, resolver) {
                 base = aliasedSym;
             }
             else if (!options.resolveDeclarationOfTemplate && isTemplatedNode(getSymNode(base))) {
-                const baseSym = getContainerTemplateSymbol(base, node.base, mapper);
+                const baseSym = getContainerTemplateSymbol(ctx, base, node.base);
                 if (!baseSym) {
                     return undefined;
                 }
@@ -2270,14 +2398,14 @@ export function createChecker(program, resolver) {
      * (i.e. they contain symbols we don't know until we've instantiated the type and the type is an
      * instantiation) we late bind the container which creates the symbol that will hold its members.
      */
-    function getAliasedSymbol(aliasSymbol, mapper) {
+    function getAliasedSymbol(ctx, aliasSymbol) {
         const node = getSymNode(aliasSymbol);
         const links = resolver.getSymbolLinks(aliasSymbol);
         if (!links.aliasResolutionIsTemplate) {
             return links.aliasedSymbol ?? resolver.getNodeLinks(node).resolvedSymbol;
         }
         // Otherwise for templates we need to get the type and retrieve the late bound symbol.
-        const aliasType = getTypeForNode(node, mapper);
+        const aliasType = getTypeForNode(node, ctx);
         return lateBindContainer(aliasType, aliasSymbol);
     }
     /** Check case where a template type member is referenced like
@@ -2286,9 +2414,9 @@ export function createChecker(program, resolver) {
      * model Test { t: Foo.t } // check `Foo` is correctly used as template
      * ```
      */
-    function getContainerTemplateSymbol(sym, node, mapper) {
+    function getContainerTemplateSymbol(ctx, sym, node) {
         if (pendingResolutions.has(sym, ResolutionKind.Type)) {
-            if (mapper === undefined) {
+            if (ctx.mapper === undefined) {
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "circular-alias-type",
                     format: { typeName: sym.name },
@@ -2298,7 +2426,7 @@ export function createChecker(program, resolver) {
             return undefined;
         }
         pendingResolutions.start(sym, ResolutionKind.Type);
-        const type = checkTypeReferenceSymbol(sym, node, mapper);
+        const type = checkTypeReferenceSymbol(ctx, sym, node);
         pendingResolutions.finish(sym, ResolutionKind.Type);
         return lateBindContainer(type, sym);
     }
@@ -2322,10 +2450,10 @@ export function createChecker(program, resolver) {
                 return getMergedSymbol(type.node.symbol) ?? sym;
         }
     }
-    function checkStringTemplateExpresion(node, mapper) {
+    function checkStringTemplateExpresion(ctx, node) {
         let hasType = false;
         let hasValue = false;
-        const spanTypeOrValues = node.spans.map((span) => [span, checkNode(span.expression, mapper)]);
+        const spanTypeOrValues = node.spans.map((span) => [span, checkNode(ctx, span.expression)]);
         for (const [_, typeOrValue] of spanTypeOrValues) {
             if (typeOrValue !== null) {
                 if (isValue(typeOrValue)) {
@@ -2538,7 +2666,7 @@ export function createChecker(program, resolver) {
     }
     function checkSourceFile(file) {
         for (const statement of file.statements) {
-            checkNode(statement, undefined);
+            checkNode(CheckContext.DEFAULT, statement, undefined);
         }
     }
     /**
@@ -2546,29 +2674,32 @@ export function createChecker(program, resolver) {
      * @param node Node with template parameters
      * @param mapper Type mapper, set if instantiating the template, undefined otherwise.
      */
-    function checkTemplateDeclaration(node, mapper) {
+    function checkTemplateDeclaration(ctx, node) {
         // If mapper is undefined it means we are checking the declaration of the template.
-        if (mapper === undefined) {
+        if (ctx.mapper === undefined) {
             for (const templateParameter of node.templateParameters) {
-                checkTemplateParameterDeclaration(templateParameter, undefined);
+                checkTemplateParameterDeclaration(ctx, templateParameter);
             }
         }
     }
-    function checkModel(node, mapper) {
+    function checkModel(ctx, node) {
         if (node.kind === SyntaxKind.ModelStatement) {
-            return checkModelStatement(node, mapper);
+            return checkModelStatement(ctx, node);
         }
         else {
-            return checkModelExpression(node, mapper);
+            return checkModelExpression(ctx, node);
         }
     }
-    function checkModelStatement(node, mapper) {
+    function checkModelStatement(ctx, node) {
         const links = getSymbolLinks(node.symbol);
-        if (links.declaredType && mapper === undefined) {
+        if (ctx.mapper === undefined && node.templateParameters.length > 0) {
+            ctx = ctx.withFlags(CheckFlags.InTemplateDeclaration);
+        }
+        if (links.declaredType && ctx.mapper === undefined) {
             // we're not instantiating this model and we've already checked it
             return links.declaredType;
         }
-        checkTemplateDeclaration(node, mapper);
+        checkTemplateDeclaration(ctx, node);
         const decorators = [];
         const type = createType({
             kind: "Model",
@@ -2580,7 +2711,7 @@ export function createChecker(program, resolver) {
             sourceModels: [],
             derivedModels: [],
         });
-        linkType(links, type, mapper);
+        linkType(ctx, links, type);
         if (node.symbol.members) {
             const members = resolver.getAugmentedSymbolTable(node.symbol.members);
             const propDocs = extractPropDocs(node);
@@ -2591,12 +2722,12 @@ export function createChecker(program, resolver) {
                 }
             }
         }
-        const isBase = checkModelIs(node, node.is, mapper);
+        const isBase = checkModelIs(ctx, node, node.is);
         ensureResolved([
             isBase,
             ...node.properties
                 .filter((x) => x.kind === SyntaxKind.ModelSpreadProperty)
-                .map((x) => checkSpreadTarget(node, x.target, mapper)),
+                .map((x) => checkSpreadTarget(ctx, node, x.target)),
         ], type, () => {
             if (isBase) {
                 type.sourceModel = isBase;
@@ -2611,7 +2742,7 @@ export function createChecker(program, resolver) {
                         sourceProperty: prop,
                         model: type,
                     });
-                    linkIndirectMember(node, newProp, mapper);
+                    linkIndirectMember(ctx, node, newProp);
                     type.properties.set(prop.name, newProp);
                 }
             }
@@ -2619,7 +2750,7 @@ export function createChecker(program, resolver) {
                 type.baseModel = isBase.baseModel;
             }
             else if (node.extends) {
-                type.baseModel = checkClassHeritage(node, node.extends, mapper);
+                type.baseModel = checkClassHeritage(ctx, node, node.extends);
                 if (type.baseModel) {
                     copyDeprecation(type.baseModel, type);
                 }
@@ -2629,14 +2760,14 @@ export function createChecker(program, resolver) {
             }
             // Hold on to the model type that's being defined so that it
             // can be referenced
-            if (mapper === undefined) {
+            if (ctx.mapper === undefined) {
                 type.namespace?.models.set(type.name, type);
             }
             // Evaluate the properties after
-            checkModelProperties(node, type.properties, type, mapper);
-            decorators.push(...checkDecorators(type, node, mapper));
-            linkMapper(type, mapper);
-            finishType(type, { skipDecorators: !shouldRunDecorators(node, mapper) });
+            checkModelProperties(ctx, node, type.properties, type);
+            decorators.push(...checkDecorators(ctx, type, node));
+            linkMapper(type, ctx.mapper);
+            finishType(type, { skipDecorators: ctx.hasFlags(CheckFlags.InTemplateDeclaration) });
             lateBindMemberContainer(type);
             lateBindMembers(type);
             const indexer = getIndexer(program, type);
@@ -2652,34 +2783,21 @@ export function createChecker(program, resolver) {
         });
         return type;
     }
-    function shouldRunDecorators(node, mapper) {
-        // Node is not a template we should create the type.
-        if (node.templateParameters.length === 0) {
-            return true;
-        }
-        // There is no mapper so we shouldn't be instantiating the template.
-        if (mapper === undefined) {
-            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) => isValue(t) || t.entityKind === "Indeterminate" || t.kind !== "TemplateParameter"));
-    }
-    function checkModelExpression(node, mapper) {
+    function checkModelExpression(ctx, node) {
         const links = getSymbolLinks(node.symbol);
-        if (links.declaredType && mapper === undefined) {
+        if (links.declaredType && ctx.mapper === undefined) {
             // we're not instantiating this model and we've already checked it
             return links.declaredType;
         }
         const type = initModel(node);
         const properties = type.properties;
-        linkType(links, type, mapper);
-        linkMapper(type, mapper);
+        linkType(ctx, links, type);
+        linkMapper(type, ctx.mapper);
         ensureResolved(node.properties
             .filter((x) => x.kind === SyntaxKind.ModelSpreadProperty)
-            .map((x) => checkSpreadTarget(node, x.target, mapper)), type, () => {
-            checkModelProperties(node, properties, type, mapper);
-            finishType(type);
+            .map((x) => checkSpreadTarget(ctx, node, x.target)), type, () => {
+            checkModelProperties(ctx, node, properties, type);
+            finishType(type, { skipDecorators: ctx.hasFlags(CheckFlags.InTemplateDeclaration) });
         });
         return type;
     }
@@ -2721,18 +2839,18 @@ export function createChecker(program, resolver) {
                     : diagnosticTarget,
             }));
     }
-    function checkModelProperties(node, properties, parentModel, mapper) {
+    function checkModelProperties(ctx, node, properties, parentModel) {
         let spreadIndexers;
         for (const prop of node.properties) {
             if ("id" in prop) {
-                const newProp = checkModelProperty(prop, mapper);
+                const newProp = checkModelProperty(ctx, prop);
                 newProp.model = parentModel;
                 checkPropertyCompatibleWithModelIndexer(parentModel, newProp, prop);
                 defineProperty(properties, newProp);
             }
             else {
                 // spread property
-                const [newProperties, additionalIndexer] = checkSpreadProperty(node.symbol, prop.target, parentModel, mapper);
+                const [newProperties, additionalIndexer] = checkSpreadProperty(ctx, node.symbol, prop.target, parentModel);
                 if (additionalIndexer) {
                     if (spreadIndexers) {
                         spreadIndexers.push(additionalIndexer);
@@ -2742,7 +2860,7 @@ export function createChecker(program, resolver) {
                     }
                 }
                 for (const newProp of newProperties) {
-                    linkIndirectMember(node, newProp, mapper);
+                    linkIndirectMember(ctx, node, newProp);
                     checkPropertyCompatibleWithModelIndexer(parentModel, newProp, prop);
                     defineProperty(properties, newProp, prop);
                 }
@@ -2758,8 +2876,8 @@ export function createChecker(program, resolver) {
             };
         }
     }
-    function checkObjectValue(node, mapper, constraint) {
-        const properties = checkObjectLiteralProperties(node, mapper);
+    function checkObjectValue(ctx, node, constraint) {
+        const properties = checkObjectLiteralProperties(ctx, node);
         if (properties === null) {
             return null;
         }
@@ -2801,12 +2919,12 @@ export function createChecker(program, resolver) {
             decorators: [],
         });
     }
-    function checkObjectLiteralProperties(node, mapper) {
+    function checkObjectLiteralProperties(ctx, node) {
         const properties = new Map();
         let hasError = false;
         for (const prop of node.properties) {
             if ("id" in prop) {
-                const value = getValueForNode(prop.value, mapper);
+                const value = getValueForNode(prop.value, ctx.mapper);
                 if (value === null) {
                     hasError = true;
                 }
@@ -2815,7 +2933,7 @@ export function createChecker(program, resolver) {
                 }
             }
             else {
-                const targetType = checkObjectSpreadProperty(prop.target, mapper);
+                const targetType = checkObjectSpreadProperty(ctx, prop.target);
                 if (targetType) {
                     for (const [name, value] of targetType.properties) {
                         properties.set(name, { ...value });
@@ -2825,8 +2943,8 @@ export function createChecker(program, resolver) {
         }
         return hasError ? null : properties;
     }
-    function checkObjectSpreadProperty(targetNode, mapper) {
-        const value = getValueForNode(targetNode, mapper);
+    function checkObjectSpreadProperty(ctx, targetNode) {
+        const value = getValueForNode(targetNode, ctx.mapper);
         if (value === null) {
             return null;
         }
@@ -2836,10 +2954,10 @@ export function createChecker(program, resolver) {
         }
         return value;
     }
-    function checkArrayValue(node, mapper, constraint) {
+    function checkArrayValue(ctx, node, constraint) {
         let hasError = false;
         const values = node.values.map((itemNode) => {
-            const value = getValueForNode(itemNode, mapper);
+            const value = getValueForNode(itemNode, ctx.mapper);
             if (value === null) {
                 hasError = true;
             }
@@ -2990,8 +3108,8 @@ export function createChecker(program, resolver) {
             value: literalType,
         }, literalType);
     }
-    function checkCallExpressionTarget(node, mapper) {
-        const target = checkTypeReference(node.target, mapper);
+    function checkCallExpressionTarget(ctx, node) {
+        const target = checkTypeReference(ctx, node.target);
         if (target.kind === "Scalar" || target.kind === "ScalarConstructor") {
             return target;
         }
@@ -3032,7 +3150,7 @@ export function createChecker(program, resolver) {
         }
         return copyValue(value, { scalar, type: scalar });
     }
-    function createScalarValue(node, mapper, declaration) {
+    function createScalarValue(ctx, node, 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
@@ -3070,7 +3188,10 @@ export function createChecker(program, resolver) {
                     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 });
+                            const arg = getValueForNode(argNode, ctx.mapper, {
+                                kind: "argument",
+                                type: restType,
+                            });
                             if (arg === null) {
                                 hasError = true;
                                 continue;
@@ -3088,7 +3209,7 @@ export function createChecker(program, resolver) {
             }
             const argNode = node.arguments[index];
             if (argNode) {
-                const arg = getValueForNode(argNode, mapper, {
+                const arg = getValueForNode(argNode, ctx.mapper, {
                     kind: "argument",
                     type: parameter.type,
                 });
@@ -3118,13 +3239,13 @@ export function createChecker(program, resolver) {
             type: declaration.scalar,
         };
     }
-    function checkCallExpression(node, mapper) {
-        const target = checkCallExpressionTarget(node, mapper);
+    function checkCallExpression(ctx, node) {
+        const target = checkCallExpressionTarget(ctx, node);
         if (target === null) {
             return null;
         }
         if (target.kind === "ScalarConstructor") {
-            return createScalarValue(node, mapper, target);
+            return createScalarValue(ctx, node, target);
         }
         if (relation.areScalarsRelated(target, getStdType("string"))) {
             return checkPrimitiveArg(node, target, "StringValue");
@@ -3144,8 +3265,8 @@ export function createChecker(program, resolver) {
             return null;
         }
     }
-    function checkTypeOfExpression(node, mapper) {
-        const entity = checkNode(node.target, mapper, undefined);
+    function checkTypeOfExpression(ctx, node) {
+        const entity = checkNode(ctx, node.target, undefined);
         if (entity === null) {
             // Shouldn't need to emit error as we assume null value already emitted error when produced
             return errorType;
@@ -3305,7 +3426,7 @@ export function createChecker(program, resolver) {
             containerMembers.set(member.name, sym);
         }
     }
-    function checkClassHeritage(model, heritageRef, mapper) {
+    function checkClassHeritage(ctx, model, heritageRef) {
         if (heritageRef.kind === SyntaxKind.ModelExpression) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "extend-model",
@@ -3326,7 +3447,7 @@ export function createChecker(program, resolver) {
         pendingResolutions.start(modelSymId, ResolutionKind.BaseType);
         const target = resolver.getNodeLinks(heritageRef).resolvedSymbol;
         if (target && pendingResolutions.has(target, ResolutionKind.BaseType)) {
-            if (mapper === undefined) {
+            if (ctx.mapper === undefined) {
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "circular-base-type",
                     format: { typeName: target.name },
@@ -3335,7 +3456,7 @@ export function createChecker(program, resolver) {
             }
             return undefined;
         }
-        const heritageType = getTypeForNode(heritageRef, mapper);
+        const heritageType = getTypeForNode(heritageRef, ctx);
         pendingResolutions.finish(modelSymId, ResolutionKind.BaseType);
         if (isErrorType(heritageType)) {
             compilerAssert(program.hasError(), "Should already have reported an error.", heritageRef);
@@ -3354,7 +3475,7 @@ export function createChecker(program, resolver) {
         }
         return heritageType;
     }
-    function checkModelIs(model, isExpr, mapper) {
+    function checkModelIs(ctx, model, isExpr) {
         if (!isExpr)
             return undefined;
         const modelSymId = getNodeSym(model);
@@ -3369,12 +3490,12 @@ export function createChecker(program, resolver) {
             return undefined;
         }
         else if (isExpr.kind === SyntaxKind.ArrayExpression) {
-            isType = checkArrayExpression(isExpr, mapper);
+            isType = checkArrayExpression(ctx, isExpr);
         }
         else if (isExpr.kind === SyntaxKind.TypeReference) {
             const target = resolver.getNodeLinks(isExpr).resolvedSymbol;
             if (target && pendingResolutions.has(target, ResolutionKind.BaseType)) {
-                if (mapper === undefined) {
+                if (ctx.mapper === undefined) {
                     reportCheckerDiagnostic(createDiagnostic({
                         code: "circular-base-type",
                         format: { typeName: target.name },
@@ -3383,7 +3504,7 @@ export function createChecker(program, resolver) {
                 }
                 return undefined;
             }
-            isType = getTypeForNode(isExpr, mapper);
+            isType = getTypeForNode(isExpr, ctx);
         }
         else {
             reportCheckerDiagnostic(createDiagnostic({ code: "is-model", target: isExpr }));
@@ -3401,11 +3522,11 @@ export function createChecker(program, resolver) {
         return isType;
     }
     /** Get the type for the spread target */
-    function checkSpreadTarget(model, target, mapper) {
+    function checkSpreadTarget(ctx, model, target) {
         const modelSymId = getNodeSym(model);
         const targetSym = resolver.getNodeLinks(target).resolvedSymbol;
         if (targetSym === modelSymId) {
-            if (mapper === undefined) {
+            if (ctx.mapper === undefined) {
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "spread-model",
                     messageId: "selfSpread",
@@ -3414,20 +3535,20 @@ export function createChecker(program, resolver) {
             }
             return undefined;
         }
-        const type = getTypeForNode(target, mapper);
+        const type = getTypeForNode(target, ctx);
         return type;
     }
-    function checkSpreadProperty(parentModelSym, targetNode, parentModel, mapper) {
-        const targetType = getTypeForNode(targetNode, mapper);
+    function checkSpreadProperty(ctx, parentModelSym, targetNode, parentModel) {
+        const targetType = getTypeForNode(targetNode, ctx);
         if (targetType.kind === "TemplateParameter" || isErrorType(targetType)) {
             return [[], undefined];
         }
         if (targetType.kind !== "Model") {
-            reportCheckerDiagnostic(createDiagnostic({ code: "spread-model", target: targetNode }), mapper);
+            reportCheckerDiagnostic(createDiagnostic({ code: "spread-model", target: targetNode }), ctx.mapper);
             return [[], undefined];
         }
-        if (isArrayModelType(program, targetType)) {
-            reportCheckerDiagnostic(createDiagnostic({ code: "spread-model", target: targetNode }), mapper);
+        if (isArrayModelType(targetType)) {
+            reportCheckerDiagnostic(createDiagnostic({ code: "spread-model", target: targetNode }), ctx.mapper);
             return [[], undefined];
         }
         parentModel.sourceModels.push({ usage: "spread", model: targetType, node: targetNode });
@@ -3448,8 +3569,8 @@ export function createChecker(program, resolver) {
      * @param member New Property
      * @param mapper Type Mapper.
      */
-    function linkIndirectMember(containerNode, member, mapper) {
-        if (mapper !== undefined) {
+    function linkIndirectMember(ctx, containerNode, member) {
+        if (ctx.mapper !== undefined) {
             return;
         }
         compilerAssert(typeof member.name === "string", "Cannot link unmapped unions");
@@ -3459,13 +3580,13 @@ export function createChecker(program, resolver) {
         const memberSym = getMemberSymbol(containerNode.symbol, member.name);
         if (memberSym) {
             const links = resolver.getSymbolLinks(memberSym);
-            linkMemberType(links, member, mapper);
+            linkMemberType(ctx, links, member);
         }
     }
-    function checkModelProperty(prop, mapper) {
+    function checkModelProperty(ctx, prop) {
         const sym = getSymbolForMember(prop);
         const links = getSymbolLinksForMember(prop);
-        if (links && links.declaredType && mapper === undefined) {
+        if (links && links.declaredType && ctx.mapper === undefined) {
             return links.declaredType;
         }
         const name = prop.id.sv;
@@ -3477,7 +3598,7 @@ export function createChecker(program, resolver) {
             type: undefined,
             decorators: [],
         });
-        if (pendingResolutions.has(sym, ResolutionKind.Type) && mapper === undefined) {
+        if (pendingResolutions.has(sym, ResolutionKind.Type) && ctx.mapper === undefined) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "circular-prop",
                 format: { propName: name },
@@ -3487,30 +3608,29 @@ export function createChecker(program, resolver) {
         }
         else {
             pendingResolutions.start(sym, ResolutionKind.Type);
-            type.type = getTypeForNode(prop.value, mapper);
+            type.type = getTypeForNode(prop.value, ctx);
             if (prop.default) {
-                const defaultValue = checkDefaultValue(prop.default, type.type, mapper);
+                const defaultValue = checkDefaultValue(ctx, prop.default, type.type);
                 if (defaultValue !== null) {
                     type.defaultValue = defaultValue;
                 }
             }
             if (links) {
-                linkType(links, type, mapper);
+                linkType(ctx, links, type);
             }
         }
-        type.decorators = checkDecorators(type, prop, mapper);
+        type.decorators = checkDecorators(ctx, type, prop);
         const parentTemplate = getParentTemplateNode(prop);
-        linkMapper(type, mapper);
-        let runDecorators = false;
-        if (!parentTemplate || shouldRunDecorators(parentTemplate, mapper)) {
+        linkMapper(type, ctx.mapper);
+        const shouldRunDecorators = !ctx.hasFlags(CheckFlags.InTemplateDeclaration);
+        if (!parentTemplate || shouldRunDecorators) {
             const docComment = docFromCommentForSym.get(sym);
             if (docComment) {
                 type.decorators.unshift(createDocFromCommentDecorator("self", docComment));
             }
-            runDecorators = true;
         }
         pendingResolutions.finish(sym, ResolutionKind.Type);
-        return finishType(type, { skipDecorators: !runDecorators });
+        return finishType(type, { skipDecorators: !shouldRunDecorators });
     }
     function createDocFromCommentDecorator(key, doc) {
         return {
@@ -3521,12 +3641,12 @@ export function createChecker(program, resolver) {
             ],
         };
     }
-    function checkDefaultValue(defaultNode, type, mapper) {
+    function checkDefaultValue(ctx, defaultNode, type) {
         if (isErrorType(type)) {
             // if the prop type is an error we don't need to validate again.
             return null;
         }
-        const defaultValue = getValueForNode(defaultNode, mapper, {
+        const defaultValue = getValueForNode(defaultNode, ctx.mapper, {
             kind: "assignment",
             type,
         });
@@ -3547,8 +3667,8 @@ export function createChecker(program, resolver) {
             return { ...defaultValue, type };
         }
     }
-    function checkDecoratorApplication(targetType, decNode, mapper) {
-        const sym = resolveTypeReferenceSym(decNode.target, undefined, true);
+    function checkDecoratorApplication(ctx, targetType, decNode) {
+        const sym = resolveTypeReferenceSym(ctx.withMapper(undefined), decNode.target, true);
         if (!sym) {
             // Error should already have been reported above
             return undefined;
@@ -3566,7 +3686,7 @@ export function createChecker(program, resolver) {
         if (symbolLinks.declaredType === undefined) {
             const decoratorDeclNode = sym.declarations.find((x) => x.kind === SyntaxKind.DecoratorDeclarationStatement);
             if (decoratorDeclNode) {
-                checkDecoratorDeclaration(decoratorDeclNode, undefined);
+                checkDecoratorDeclaration(ctx.withMapper(undefined), decoratorDeclNode);
             }
         }
         if (symbolLinks.declaredType) {
@@ -3575,7 +3695,7 @@ export function createChecker(program, resolver) {
                 hasError = true;
             }
         }
-        const [argsHaveError, args] = checkDecoratorArguments(decNode, mapper, symbolLinks.declaredType);
+        const [argsHaveError, args] = checkDecoratorArguments(ctx, decNode, symbolLinks.declaredType);
         if (hasError || argsHaveError) {
             return undefined;
         }
@@ -3603,13 +3723,13 @@ export function createChecker(program, resolver) {
         }
         return targetValid;
     }
-    function checkDecoratorArguments(node, mapper, declaration) {
+    function checkDecoratorArguments(ctx, node, 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;
+                    let type = checkNode(ctx, argNode) ?? errorType;
                     if (type.entityKind === "Indeterminate") {
                         type = type.type;
                     }
@@ -3652,7 +3772,7 @@ export function createChecker(program, resolver) {
         }
         const resolvedArgs = [];
         function resolveArg(argNode, perParamType) {
-            const arg = getTypeOrValueForNode(argNode, mapper, {
+            const arg = getTypeOrValueForNode(argNode, ctx.mapper, {
                 kind: "argument",
                 constraint: perParamType,
             });
@@ -3709,8 +3829,7 @@ export function createChecker(program, resolver) {
         let valueType;
         let type;
         if (constraint.valueType) {
-            if (constraint.valueType.kind === "Model" &&
-                isArrayModelType(program, constraint.valueType)) {
+            if (constraint.valueType.kind === "Model" && isArrayModelType(constraint.valueType)) {
                 valueType = constraint.valueType.indexer.value;
             }
             else {
@@ -3718,7 +3837,7 @@ export function createChecker(program, resolver) {
             }
         }
         if (constraint.type) {
-            if (constraint.type.kind === "Model" && isArrayModelType(program, constraint.type)) {
+            if (constraint.type.kind === "Model" && isArrayModelType(constraint.type)) {
                 type = constraint.type.indexer.value;
             }
             else {
@@ -3759,11 +3878,11 @@ export function createChecker(program, resolver) {
         }
         return valid;
     }
-    function checkAugmentDecorators(sym, targetType, mapper) {
+    function checkAugmentDecorators(ctx, sym, targetType) {
         const augmentDecoratorNodes = resolver.getAugmentDecoratorsForSym(sym);
         const decorators = [];
         for (const decNode of augmentDecoratorNodes) {
-            const decorator = checkDecoratorApplication(targetType, decNode, mapper);
+            const decorator = checkDecoratorApplication(ctx, targetType, decNode);
             if (decorator) {
                 decorators.unshift(decorator);
             }
@@ -3773,9 +3892,11 @@ export function createChecker(program, resolver) {
     /**
      * Check that augment decorator are targeting valid symbols.
      */
-    function checkAugmentDecorator(node) {
+    function checkAugmentDecorator(ctx, node) {
         // This will validate the target type is pointing to a valid ref.
-        resolveTypeReferenceSym(node.targetType, undefined, { resolveDeclarationOfTemplate: true });
+        resolveTypeReferenceSym(ctx.withMapper(undefined), node.targetType, {
+            resolveDeclarationOfTemplate: true,
+        });
         const links = resolver.getNodeLinks(node.targetType);
         if (links.isTemplateInstantiation) {
             program.reportDiagnostic(createDiagnostic({
@@ -3811,8 +3932,8 @@ export function createChecker(program, resolver) {
     /**
      * Check that using statements are targeting valid symbols.
      */
-    function checkUsings(node) {
-        const usedSym = resolveTypeReferenceSym(node.name, undefined);
+    function checkUsings(ctx, node) {
+        const usedSym = resolveTypeReferenceSym(ctx.withMapper(undefined), node.name);
         if (usedSym) {
             if (~usedSym.flags & 256 /* SymbolFlags.Namespace */) {
                 reportCheckerDiagnostic(createDiagnostic({ code: "using-invalid-ref", target: node.name }));
@@ -3821,7 +3942,7 @@ export function createChecker(program, resolver) {
         // If this was used to get a type this is invalid, only used for validation.
         return errorType;
     }
-    function checkDecorators(targetType, node, mapper) {
+    function checkDecorators(ctx, targetType, node) {
         const sym = isMemberNode(node)
             ? (getSymbolForMember(node) ?? node.symbol)
             : getMergedSymbol(node.symbol);
@@ -3832,7 +3953,7 @@ export function createChecker(program, resolver) {
             ...node.decorators,
         ];
         for (const decNode of decoratorNodes) {
-            const decorator = checkDecoratorApplication(targetType, decNode, mapper);
+            const decorator = checkDecoratorApplication(ctx, targetType, decNode);
             if (decorator) {
                 decorators.unshift(decorator);
             }
@@ -3855,13 +3976,17 @@ export function createChecker(program, resolver) {
         }
         return decorators;
     }
-    function checkScalar(node, mapper) {
+    function checkScalar(ctx, node) {
         const links = getSymbolLinks(node.symbol);
-        if (links.declaredType && mapper === undefined) {
+        if (ctx.mapper === undefined && node.templateParameters.length > 0) {
+            // This is a templated declaration and we are not instantiating it, so we need to update the flags.
+            ctx = ctx.withFlags(CheckFlags.InTemplateDeclaration);
+        }
+        if (links.declaredType && ctx.mapper === undefined) {
             // we're not instantiating this model and we've already checked it
             return links.declaredType;
         }
-        checkTemplateDeclaration(node, mapper);
+        checkTemplateDeclaration(ctx, node);
         const decorators = [];
         const type = createType({
             kind: "Scalar",
@@ -3872,31 +3997,31 @@ export function createChecker(program, resolver) {
             decorators,
             derivedScalars: [],
         });
-        linkType(links, type, mapper);
+        linkType(ctx, links, type);
         if (node.extends) {
-            type.baseScalar = checkScalarExtends(node, node.extends, mapper);
+            type.baseScalar = checkScalarExtends(ctx, node, node.extends);
             if (type.baseScalar) {
                 copyDeprecation(type.baseScalar, type);
                 type.baseScalar.derivedScalars.push(type);
             }
         }
-        checkScalarConstructors(type, node, type.constructors, mapper);
-        decorators.push(...checkDecorators(type, node, mapper));
-        if (mapper === undefined) {
+        checkScalarConstructors(ctx, type, node, type.constructors);
+        decorators.push(...checkDecorators(ctx, type, node));
+        if (ctx.mapper === undefined) {
             type.namespace?.scalars.set(type.name, type);
         }
-        linkMapper(type, mapper);
+        linkMapper(type, ctx.mapper);
         if (isInTypeSpecNamespace(type)) {
             stdTypes[type.name] = type;
         }
-        return finishType(type, { skipDecorators: !shouldRunDecorators(node, mapper) });
+        return finishType(type, { skipDecorators: ctx.hasFlags(CheckFlags.InTemplateDeclaration) });
     }
-    function checkScalarExtends(scalar, extendsRef, mapper) {
+    function checkScalarExtends(ctx, scalar, extendsRef) {
         const symId = getNodeSym(scalar);
         pendingResolutions.start(symId, ResolutionKind.BaseType);
         const target = resolver.getNodeLinks(extendsRef).resolvedSymbol;
         if (target && pendingResolutions.has(target, ResolutionKind.BaseType)) {
-            if (mapper === undefined) {
+            if (ctx.mapper === undefined) {
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "circular-base-type",
                     format: { typeName: target.declarations[0].id.sv },
@@ -3905,7 +4030,7 @@ export function createChecker(program, resolver) {
             }
             return undefined;
         }
-        const extendsType = getTypeForNode(extendsRef, mapper);
+        const extendsType = getTypeForNode(extendsRef, ctx);
         pendingResolutions.finish(symId, ResolutionKind.BaseType);
         if (isErrorType(extendsType)) {
             compilerAssert(program.hasError(), "Should already have reported an error.", extendsRef);
@@ -3917,19 +4042,19 @@ export function createChecker(program, resolver) {
         }
         return extendsType;
     }
-    function checkScalarConstructors(parentScalar, node, constructors, mapper) {
+    function checkScalarConstructors(ctx, parentScalar, node, constructors) {
         if (parentScalar.baseScalar) {
             for (const member of parentScalar.baseScalar.constructors.values()) {
                 const newConstructor = cloneTypeForSymbol(getMemberSymbol(node.symbol, member.name), {
                     ...member,
                     scalar: parentScalar,
                 });
-                linkIndirectMember(node, newConstructor, mapper);
+                linkIndirectMember(ctx, node, newConstructor);
                 constructors.set(member.name, newConstructor);
             }
         }
         for (const member of node.members) {
-            const constructor = checkScalarConstructor(member, mapper, parentScalar);
+            const constructor = checkScalarConstructor(ctx, member, parentScalar);
             if (constructors.has(constructor.name)) {
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "constructor-duplicate",
@@ -3941,10 +4066,10 @@ export function createChecker(program, resolver) {
             constructors.set(constructor.name, constructor);
         }
     }
-    function checkScalarConstructor(node, mapper, parentScalar) {
+    function checkScalarConstructor(ctx, node, parentScalar) {
         const name = node.id.sv;
         const links = getSymbolLinksForMember(node);
-        if (links && links.declaredType && mapper === undefined) {
+        if (links && links.declaredType && ctx.mapper === undefined) {
             // we're not instantiating this scalar constructor and we've already checked it
             return links.declaredType;
         }
@@ -3953,25 +4078,29 @@ export function createChecker(program, resolver) {
             scalar: parentScalar,
             name,
             node,
-            parameters: node.parameters.map((x) => checkFunctionParameter(x, mapper, false)),
+            parameters: node.parameters.map((x) => checkFunctionParameter(ctx, x, false)),
         });
-        linkMapper(member, mapper);
+        linkMapper(member, ctx.mapper);
         if (links) {
-            linkType(links, member, mapper);
+            linkType(ctx, links, member);
         }
         return finishType(member, {
-            skipDecorators: !shouldRunDecorators(node.parent, mapper),
+            skipDecorators: ctx.hasFlags(CheckFlags.InTemplateDeclaration),
         });
     }
-    function checkAlias(node, mapper) {
+    function checkAlias(ctx, node) {
         const links = getSymbolLinks(node.symbol);
-        if (links.declaredType && mapper === undefined) {
+        if (ctx.mapper === undefined && node.templateParameters.length > 0) {
+            // This is a templated declaration and we are not instantiating it, so we need to update the flags.
+            ctx = ctx.withFlags(CheckFlags.InTemplateDeclaration);
+        }
+        if (links.declaredType && ctx.mapper === undefined) {
             return links.declaredType;
         }
-        checkTemplateDeclaration(node, mapper);
+        checkTemplateDeclaration(ctx, node);
         const aliasSymId = getNodeSym(node);
         if (pendingResolutions.has(aliasSymId, ResolutionKind.Type)) {
-            if (mapper === undefined) {
+            if (ctx.mapper === undefined) {
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "circular-alias-type",
                     format: { typeName: node.id.sv },
@@ -3982,7 +4111,7 @@ export function createChecker(program, resolver) {
             return errorType;
         }
         pendingResolutions.start(aliasSymId, ResolutionKind.Type);
-        const type = checkNode(node.value, mapper);
+        const type = checkNode(ctx, node.value);
         if (type === null) {
             links.declaredType = errorType;
             return errorType;
@@ -3992,7 +4121,7 @@ export function createChecker(program, resolver) {
             links.declaredType = errorType;
             return errorType;
         }
-        linkType(links, type, mapper);
+        linkType(ctx, links, type);
         pendingResolutions.finish(aliasSymId, ResolutionKind.Type);
         return type;
     }
@@ -4038,7 +4167,7 @@ export function createChecker(program, resolver) {
                 return value;
         }
     }
-    function checkEnum(node, mapper) {
+    function checkEnum(ctx, node) {
         const links = getSymbolLinks(node.symbol);
         if (!links.type) {
             const enumType = (links.type = createType({
@@ -4051,7 +4180,7 @@ export function createChecker(program, resolver) {
             const memberNames = new Set();
             for (const member of node.members) {
                 if (member.kind === SyntaxKind.EnumMember) {
-                    const memberType = checkEnumMember(member, mapper, enumType);
+                    const memberType = checkEnumMember(ctx, member, enumType);
                     if (memberNames.has(memberType.name)) {
                         reportCheckerDiagnostic(createDiagnostic({
                             code: "enum-member-duplicate",
@@ -4064,9 +4193,9 @@ export function createChecker(program, resolver) {
                     enumType.members.set(memberType.name, memberType);
                 }
                 else {
-                    const members = checkEnumSpreadMember(node.symbol, enumType, member.target, mapper, memberNames);
+                    const members = checkEnumSpreadMember(ctx, node.symbol, enumType, member.target, memberNames);
                     for (const memberType of members) {
-                        linkIndirectMember(node, memberType, mapper);
+                        linkIndirectMember(ctx, node, memberType);
                         enumType.members.set(memberType.name, memberType);
                     }
                 }
@@ -4074,19 +4203,23 @@ export function createChecker(program, resolver) {
             const namespace = getParentNamespaceType(node);
             enumType.namespace = namespace;
             enumType.namespace?.enums.set(enumType.name, enumType);
-            enumType.decorators = checkDecorators(enumType, node, mapper);
-            linkMapper(enumType, mapper);
+            enumType.decorators = checkDecorators(ctx, enumType, node);
+            linkMapper(enumType, ctx.mapper);
             finishType(enumType);
         }
         return links.type;
     }
-    function checkInterface(node, mapper) {
+    function checkInterface(ctx, node) {
         const links = getSymbolLinks(node.symbol);
-        if (links.declaredType && mapper === undefined) {
+        if (ctx.mapper === undefined && node.templateParameters.length > 0) {
+            // This is a templated declaration and we are not instantiating it, so we need to update the flags.
+            ctx = ctx.withFlags(CheckFlags.InTemplateDeclaration);
+        }
+        if (links.declaredType && ctx.mapper === undefined) {
             // we're not instantiating this interface and we've already checked it
             return links.declaredType;
         }
-        checkTemplateDeclaration(node, mapper);
+        checkTemplateDeclaration(ctx, node);
         const interfaceType = createType({
             kind: "Interface",
             decorators: [],
@@ -4096,11 +4229,11 @@ export function createChecker(program, resolver) {
             operations: createRekeyableMap(),
             name: node.id.sv,
         });
-        linkType(links, interfaceType, mapper);
-        interfaceType.decorators = checkDecorators(interfaceType, node, mapper);
-        const ownMembers = checkInterfaceMembers(node, mapper, interfaceType);
+        linkType(ctx, links, interfaceType);
+        interfaceType.decorators = checkDecorators(ctx, interfaceType, node);
+        const ownMembers = checkInterfaceMembers(ctx, node, interfaceType);
         for (const extendsNode of node.extends) {
-            const extendsType = getTypeForNode(extendsNode, mapper);
+            const extendsType = getTypeForNode(extendsNode, ctx);
             if (extendsType.kind !== "Interface") {
                 reportCheckerDiagnostic(createDiagnostic({ code: "extends-interface", target: extendsNode }));
                 continue;
@@ -4118,7 +4251,7 @@ export function createChecker(program, resolver) {
                 });
                 // Don't link it it is overritten
                 if (!ownMembers.has(member.name)) {
-                    linkIndirectMember(node, newMember, mapper);
+                    linkIndirectMember(ctx, node, newMember);
                 }
                 // Clone deprecation information
                 copyDeprecation(member, newMember);
@@ -4129,17 +4262,17 @@ export function createChecker(program, resolver) {
         for (const [key, value] of ownMembers) {
             interfaceType.operations.set(key, value);
         }
-        linkMapper(interfaceType, mapper);
-        if (mapper === undefined) {
+        linkMapper(interfaceType, ctx.mapper);
+        if (ctx.mapper === undefined) {
             interfaceType.namespace?.interfaces.set(interfaceType.name, interfaceType);
         }
         lateBindMemberContainer(interfaceType);
         lateBindMembers(interfaceType);
         return finishType(interfaceType, {
-            skipDecorators: !shouldRunDecorators(node, mapper),
+            skipDecorators: ctx.hasFlags(CheckFlags.InTemplateDeclaration),
         });
     }
-    function checkInterfaceMembers(node, mapper, interfaceType) {
+    function checkInterfaceMembers(ctx, node, interfaceType) {
         const ownMembers = new Map();
         // Preregister each operation sym links instantiation to make sure there is no race condition when instantiating templated interface
         for (const opNode of node.operations) {
@@ -4150,7 +4283,7 @@ export function createChecker(program, resolver) {
             }
         }
         for (const opNode of node.operations) {
-            const opType = checkOperation(opNode, mapper, interfaceType);
+            const opType = checkOperation(ctx, opNode, interfaceType);
             if (ownMembers.has(opType.name)) {
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "interface-duplicate",
@@ -4163,13 +4296,16 @@ export function createChecker(program, resolver) {
         }
         return ownMembers;
     }
-    function checkUnion(node, mapper) {
+    function checkUnion(ctx, node) {
         const links = getSymbolLinks(node.symbol);
-        if (links.declaredType && mapper === undefined) {
+        if (ctx.mapper === undefined && node.templateParameters.length > 0) {
+            ctx = ctx.withFlags(CheckFlags.InTemplateDeclaration);
+        }
+        if (links.declaredType && ctx.mapper === undefined) {
             // we're not instantiating this union and we've already checked it
             return links.declaredType;
         }
-        checkTemplateDeclaration(node, mapper);
+        checkTemplateDeclaration(ctx, node);
         const variants = createRekeyableMap();
         const unionType = createType({
             kind: "Union",
@@ -4183,20 +4319,22 @@ export function createChecker(program, resolver) {
             },
             expression: false,
         });
-        linkType(links, unionType, mapper);
-        unionType.decorators = checkDecorators(unionType, node, mapper);
-        checkUnionVariants(unionType, node, variants, mapper);
-        linkMapper(unionType, mapper);
-        if (mapper === undefined) {
+        linkType(ctx, links, unionType);
+        unionType.decorators = checkDecorators(ctx, unionType, node);
+        checkUnionVariants(ctx, unionType, node, variants);
+        linkMapper(unionType, ctx.mapper);
+        if (ctx.mapper === undefined) {
             unionType.namespace?.unions.set(unionType.name, unionType);
         }
         lateBindMemberContainer(unionType);
         lateBindMembers(unionType);
-        return finishType(unionType, { skipDecorators: !shouldRunDecorators(node, mapper) });
+        return finishType(unionType, {
+            skipDecorators: ctx.hasFlags(CheckFlags.InTemplateDeclaration),
+        });
     }
-    function checkUnionVariants(parentUnion, node, variants, mapper) {
+    function checkUnionVariants(ctx, parentUnion, node, variants) {
         for (const variantNode of node.options) {
-            const variantType = checkUnionVariant(variantNode, mapper);
+            const variantType = checkUnionVariant(ctx, variantNode);
             variantType.union = parentUnion;
             if (variants.has(variantType.name)) {
                 reportCheckerDiagnostic(createDiagnostic({
@@ -4209,14 +4347,14 @@ export function createChecker(program, resolver) {
             variants.set(variantType.name, variantType);
         }
     }
-    function checkUnionVariant(variantNode, mapper) {
+    function checkUnionVariant(ctx, variantNode) {
         const links = getSymbolLinksForMember(variantNode);
-        if (links && links.declaredType && mapper === undefined) {
+        if (links && links.declaredType && ctx.mapper === undefined) {
             // we're not instantiating this union variant and we've already checked it
             return links.declaredType;
         }
         const name = variantNode.id ? variantNode.id.sv : Symbol("name");
-        const type = getTypeForNode(variantNode.value, mapper);
+        const type = getTypeForNode(variantNode.value, ctx);
         const variantType = createType({
             kind: "UnionVariant",
             name,
@@ -4225,13 +4363,13 @@ export function createChecker(program, resolver) {
             type,
             union: undefined,
         });
-        variantType.decorators = checkDecorators(variantType, variantNode, mapper);
-        linkMapper(variantType, mapper);
+        variantType.decorators = checkDecorators(ctx, variantType, variantNode);
+        linkMapper(variantType, ctx.mapper);
         if (links) {
-            linkType(links, variantType, mapper);
+            linkType(ctx, links, variantType);
         }
         return finishType(variantType, {
-            skipDecorators: !shouldRunDecorators(variantNode.parent, mapper),
+            skipDecorators: ctx.hasFlags(CheckFlags.InTemplateDeclaration),
         });
     }
     function isMemberNode(node) {
@@ -4252,7 +4390,7 @@ export function createChecker(program, resolver) {
         const sym = getSymbolForMember(node);
         return sym ? (getSymNode(sym) === node ? getSymbolLinks(sym) : undefined) : undefined;
     }
-    function checkEnumMember(node, mapper, parentEnum) {
+    function checkEnumMember(ctx, node, parentEnum) {
         const name = node.id.sv;
         const links = getSymbolLinksForMember(node);
         if (links?.type) {
@@ -4271,12 +4409,12 @@ export function createChecker(program, resolver) {
         if (links) {
             links.type = member;
         }
-        member.decorators = checkDecorators(member, node, mapper);
+        member.decorators = checkDecorators(ctx, member, node);
         return finishType(member);
     }
-    function checkEnumSpreadMember(parentEnumSym, parentEnum, targetNode, mapper, existingMemberNames) {
+    function checkEnumSpreadMember(ctx, parentEnumSym, parentEnum, targetNode, existingMemberNames) {
         const members = [];
-        const targetType = getTypeForNode(targetNode, mapper);
+        const targetType = getTypeForNode(targetNode, ctx);
         if (!isErrorType(targetType)) {
             if (targetType.kind !== "Enum") {
                 reportCheckerDiagnostic(createDiagnostic({ code: "spread-enum", target: targetNode }));
@@ -4446,7 +4584,7 @@ export function createChecker(program, resolver) {
             decorators: [],
         });
         getSymbolLinks(sym).type = type;
-        type.decorators = checkAugmentDecorators(sym, type, undefined);
+        type.decorators = checkAugmentDecorators(CheckContext.DEFAULT, sym, type);
         return finishType(type);
     }
     function initializeClone(type, additionalProps) {
@@ -4559,7 +4697,7 @@ export function createChecker(program, resolver) {
             if (docComment) {
                 clone.decorators.push(createDocFromCommentDecorator("self", docComment));
             }
-            for (const dec of checkAugmentDecorators(sym, clone, undefined)) {
+            for (const dec of checkAugmentDecorators(CheckContext.DEFAULT, sym, clone)) {
                 clone.decorators.push(dec);
             }
         }