@typespec/compiler 0.47.0-dev.7 → 0.47.0

package/dist/src/core/checker.js

@@ -1,5 +1,6 @@
-import { $docFromComment, getDeprecated, getIndexer } from "../lib/decorators.js";
+import { $docFromComment, getIndexer } from "../lib/decorators.js";
 import { createSymbol, createSymbolTable } from "./binder.js";
+import { getDeprecationDetails, markDeprecated } from "./deprecation.js";
 import { ProjectionError, compilerAssert, reportDeprecated } from "./diagnostics.js";
 import { validateInheritanceDiscriminatedUnions } from "./helpers/discriminator-utils.js";
 import { getNamespaceFullName, getTypeName } from "./helpers/index.js";
@@ -170,6 +171,7 @@ export function createChecker(program) {
             }
             if (!(sym.flags & 4096 /* SymbolFlags.Namespace */)) {
                 reportCheckerDiagnostic(createDiagnostic({ code: "using-invalid-ref", target: using }));
+                continue;
             }
             const namespaceSym = getMergedSymbol(sym);
             if (usedUsing.has(namespaceSym)) {
@@ -487,7 +489,6 @@ export function createChecker(program) {
             return errorType;
         }
         const type = checkTypeReferenceSymbol(sym, node, mapper, instantiateTemplate);
-        checkDeprecated(type, node);
         return type;
     }
     function resolveTypeReference(node) {
@@ -498,16 +499,23 @@ export function createChecker(program) {
         onCheckerDiagnostic = oldDiagnosticHook;
         return [type === errorType ? undefined : type, diagnostics];
     }
-    function checkDeprecated(type, target) {
-        const deprecated = getDeprecated(program, type);
-        if (deprecated) {
-            reportCheckerDiagnostic(createDiagnostic({
-                code: "deprecated",
-                format: {
-                    message: deprecated,
-                },
-                target,
-            }));
+    function copyDeprecation(sourceType, destType) {
+        const deprecationDetails = getDeprecationDetails(program, sourceType);
+        if (deprecationDetails) {
+            markDeprecated(program, destType, deprecationDetails);
+        }
+    }
+    function checkDeprecated(type, node, target) {
+        if (node) {
+            const deprecationDetails = getDeprecationDetails(program, node);
+            if (deprecationDetails) {
+                reportDeprecation(program, target, deprecationDetails.message, reportCheckerDiagnostic);
+                return;
+            }
+        }
+        const deprecationDetails = getDeprecationDetails(program, type);
+        if (deprecationDetails) {
+            reportDeprecation(program, target, deprecationDetails.message, reportCheckerDiagnostic);
         }
     }
     function checkTypeReferenceArgs(node, mapper) {
@@ -665,6 +673,11 @@ export function createChecker(program) {
                 }
             }
         }
+        // Check for deprecations here, first on symbol, then on type.
+        const declarationNode = sym === null || sym === void 0 ? void 0 : sym.declarations[0];
+        if (declarationNode && mapper === undefined) {
+            checkDeprecated(baseType, declarationNode, node);
+        }
         return baseType;
     }
     /**
@@ -1070,7 +1083,8 @@ export function createChecker(program) {
     function checkOperation(node, mapper, parentInterface) {
         var _a;
         const inInterface = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.kind) === SyntaxKind.InterfaceStatement;
-        const links = inInterface ? getSymbolLinksForMember(node) : getSymbolLinks(node.symbol);
+        const symbol = inInterface ? getSymbolForMember(node) : node.symbol;
+        const links = symbol && getSymbolLinks(symbol);
         if (links) {
             if (links.declaredType && mapper === undefined) {
                 // we're not instantiating this operation and we've already checked it
@@ -1080,6 +1094,7 @@ export function createChecker(program) {
         if (mapper === undefined && inInterface) {
             compilerAssert(parentInterface, "Operation in interface should already have been checked.");
         }
+        checkTemplateDeclaration(node, mapper);
         // If we are instantating operation inside of interface
         if (isTemplatedNode(node) && mapper !== undefined && parentInterface) {
             mapper = { ...mapper, partial: true };
@@ -1096,8 +1111,19 @@ export function createChecker(program) {
                 return errorType;
             }
             sourceOperation = baseOperation;
+            const parameterModelSym = getOrCreateAugmentedSymbolTable(symbol.metatypeMembers).get("parameters");
             // Reference the same return type and create the parameters type
-            parameters = cloneType(baseOperation.parameters);
+            const clone = initializeClone(baseOperation.parameters, {
+                properties: createRekeyableMap(),
+            });
+            clone.properties = createRekeyableMap(Array.from(baseOperation.parameters.properties.entries()).map(([key, prop]) => [
+                key,
+                cloneTypeForSymbol(getMemberSymbol(parameterModelSym, prop.name), prop, {
+                    model: clone,
+                    sourceProperty: prop,
+                }),
+            ]));
+            parameters = finishType(clone);
             returnType = baseOperation.returnType;
             // Copy decorators from the base operation, inserting the base decorators first
             decorators = [...baseOperation.decorators];
@@ -1567,6 +1593,14 @@ export function createChecker(program) {
     }
     function resolveMetaProperty(node, base) {
         const resolved = resolveIdentifierInTable(node.id, base.metatypeMembers);
+        if (!resolved) {
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "invalid-ref",
+                messageId: "metaProperty",
+                format: { kind: getMemberKindName(base.declarations[0]), id: node.id.sv },
+                target: node,
+            }));
+        }
         return resolved;
     }
     function getMemberKindName(node) {
@@ -1574,6 +1608,8 @@ export function createChecker(program) {
             case SyntaxKind.ModelStatement:
             case SyntaxKind.ModelExpression:
                 return "Model";
+            case SyntaxKind.ModelProperty:
+                return "ModelProperty";
             case SyntaxKind.EnumStatement:
                 return "Enum";
             case SyntaxKind.InterfaceStatement:
@@ -1672,6 +1708,19 @@ export function createChecker(program) {
             getTypeForNode(statement, undefined);
         }
     }
+    /**
+     * Check that the given node template parameters are valid if applicable.
+     * @param node Node with template parameters
+     * @param mapper Type mapper, set if instantiating the template, undefined otherwise.
+     */
+    function checkTemplateDeclaration(node, mapper) {
+        // If mapper is undefined it means we are checking the declaration of the template.
+        if (mapper === undefined) {
+            for (const templateParameter of node.templateParameters) {
+                checkTemplateParameterDeclaration(templateParameter, undefined);
+            }
+        }
+    }
     function checkModel(node, mapper) {
         if (node.kind === SyntaxKind.ModelStatement) {
             return checkModelStatement(node, mapper);
@@ -1687,6 +1736,7 @@ export function createChecker(program) {
             // we're not instantiating this model and we've already checked it
             return links.declaredType;
         }
+        checkTemplateDeclaration(node, mapper);
         const decorators = [];
         const type = createType({
             kind: "Model",
@@ -1701,7 +1751,6 @@ export function createChecker(program) {
         const isBase = checkModelIs(node, node.is, mapper);
         if (isBase) {
             type.sourceModel = isBase;
-            checkDeprecated(isBase, node.is);
             // copy decorators
             decorators.push(...isBase.decorators);
             if (isBase.indexer) {
@@ -1725,7 +1774,7 @@ export function createChecker(program) {
         else if (node.extends) {
             type.baseModel = checkClassHeritage(node, node.extends, mapper);
             if (type.baseModel) {
-                checkDeprecated(type.baseModel, node.extends);
+                copyDeprecation(type.baseModel, type);
             }
         }
         if (type.baseModel) {
@@ -1738,13 +1787,6 @@ export function createChecker(program) {
         }
         // Evaluate the properties after
         checkModelProperties(node, type.properties, type, mapper);
-        for (const prop of walkPropertiesInherited(type)) {
-            const table = getOrCreateAugmentedSymbolTable(node.symbol.members);
-            const sym = table.get(prop.name);
-            if (sym) {
-                mutate(sym).type = prop;
-            }
-        }
         linkMapper(type, mapper);
         if (shouldCreateTypeForTemplate(node, mapper)) {
             finishType(type);
@@ -1808,7 +1850,7 @@ export function createChecker(program) {
             }
             else {
                 // spread property
-                const newProperties = checkSpreadProperty(prop.target, parentModel, mapper);
+                const newProperties = checkSpreadProperty(node.symbol, prop.target, parentModel, mapper);
                 for (const newProp of newProperties) {
                     linkIndirectMember(node, newProp, mapper);
                     checkPropertyCompatibleWithIndexer(parentModel, newProp, prop);
@@ -1908,6 +1950,9 @@ export function createChecker(program) {
                     break;
                 case SyntaxKind.UnionStatement:
                     for (const variant of node.options.values()) {
+                        if (!variant.id) {
+                            continue;
+                        }
                         const name = variant.id.sv;
                         bindMember(name, variant, 1024 /* SymbolFlags.UnionVariant */);
                     }
@@ -1953,40 +1998,68 @@ export function createChecker(program) {
             }
         }
     }
-    function bindMetaTypes(node) {
+    function copyMembersToContainer(targetContainerSym, table) {
         var _a;
-        switch (node.kind) {
-            case SyntaxKind.ModelProperty: {
-                const sym = getSymbolForMember(node);
-                if (sym) {
-                    const table = getOrCreateAugmentedSymbolTable(sym.metatypeMembers);
-                    table.set("type", node.value.kind === SyntaxKind.TypeReference
-                        ? createSymbol(node.value, "", 2048 /* SymbolFlags.Alias */)
-                        : node.value.symbol);
-                }
-                break;
+        const members = (_a = augmentedSymbolTables.get(table)) !== null && _a !== void 0 ? _a : table;
+        compilerAssert(targetContainerSym.members, "containerSym.members is undefined");
+        const containerMembers = getOrCreateAugmentedSymbolTable(targetContainerSym.members);
+        for (const member of members.values()) {
+            bindMemberToContainer(targetContainerSym, containerMembers, member.name, member.declarations[0], member.flags);
+        }
+    }
+    function bindMemberToContainer(containerSym, containerMembers, name, node, kind) {
+        const sym = createSymbol(node, name, kind, containerSym);
+        compilerAssert(containerSym.members, "containerSym.members is undefined");
+        containerMembers.set(name, sym);
+    }
+    function bindMetaTypes(node) {
+        const visited = new Set();
+        function visit(node, symbol) {
+            var _a;
+            if (visited.has(node)) {
+                return;
             }
-            case SyntaxKind.OperationStatement: {
-                const sym = (_a = node.symbol) !== null && _a !== void 0 ? _a : getSymbolForMember(node);
-                const table = getOrCreateAugmentedSymbolTable(sym.metatypeMembers);
-                if (node.signature.kind === SyntaxKind.OperationSignatureDeclaration) {
-                    table.set("parameters", node.signature.parameters.symbol);
-                    table.set("returnType", node.signature.returnType.symbol);
+            visited.add(node);
+            switch (node.kind) {
+                case SyntaxKind.ModelProperty: {
+                    const sym = getSymbolForMember(node);
+                    if (sym) {
+                        const table = getOrCreateAugmentedSymbolTable(sym.metatypeMembers);
+                        table.set("type", node.value.kind === SyntaxKind.TypeReference
+                            ? createSymbol(node.value, "", 2048 /* SymbolFlags.Alias */)
+                            : node.value.symbol);
+                    }
+                    break;
                 }
-                else {
-                    const sig = resolveTypeReferenceSym(node.signature.baseOperation, undefined);
-                    if (sig) {
-                        const sigTable = getOrCreateAugmentedSymbolTable(sig.metatypeMembers);
-                        table.set("parameters", sigTable.get("parameters"));
-                        table.set("returnType", sigTable.get("returnType"));
+                case SyntaxKind.OperationStatement: {
+                    const sym = (_a = symbol !== null && symbol !== void 0 ? symbol : node.symbol) !== null && _a !== void 0 ? _a : getSymbolForMember(node);
+                    const table = getOrCreateAugmentedSymbolTable(sym.metatypeMembers);
+                    if (node.signature.kind === SyntaxKind.OperationSignatureDeclaration) {
+                        table.set("parameters", node.signature.parameters.symbol);
+                        table.set("returnType", node.signature.returnType.symbol);
+                    }
+                    else {
+                        const sig = resolveTypeReferenceSym(node.signature.baseOperation, undefined);
+                        if (sig) {
+                            visit(sig.declarations[0], sig);
+                            const sigTable = getOrCreateAugmentedSymbolTable(sig.metatypeMembers);
+                            const sigParameterSym = sigTable.get("parameters");
+                            if (sigParameterSym !== undefined) {
+                                const parametersSym = createSymbol(sigParameterSym.declarations[0], "parameters", 2 /* SymbolFlags.Model */ & 674 /* SymbolFlags.MemberContainer */);
+                                copyMembersToContainer(parametersSym, sigParameterSym.members);
+                                table.set("parameters", parametersSym);
+                                table.set("returnType", sigTable.get("returnType"));
+                            }
+                        }
                     }
+                    break;
                 }
-                break;
             }
+            visitChildren(node, (child) => {
+                bindMetaTypes(child);
+            });
         }
-        visitChildren(node, (child) => {
-            bindMetaTypes(child);
-        });
+        visit(node);
     }
     /**
      * Initializes a late bound symbol for the type. This is generally necessary when attempting to
@@ -2148,7 +2221,7 @@ export function createChecker(program) {
         }
         return isType;
     }
-    function checkSpreadProperty(targetNode, parentModel, mapper) {
+    function checkSpreadProperty(parentModelSym, targetNode, parentModel, mapper) {
         const targetType = getTypeForNode(targetNode, mapper);
         if (targetType.kind === "TemplateParameter" || isErrorType(targetType)) {
             return [];
@@ -2160,7 +2233,8 @@ export function createChecker(program) {
         const props = [];
         // copy each property
         for (const prop of walkPropertiesInherited(targetType)) {
-            props.push(cloneType(prop, {
+            const memberSym = getMemberSymbol(parentModelSym, prop.name);
+            props.push(cloneTypeForSymbol(memberSym, prop, {
                 sourceProperty: prop,
                 model: parentModel,
             }));
@@ -2393,6 +2467,18 @@ export function createChecker(program) {
         }
         return valid;
     }
+    function checkAugmentDecorators(sym, targetType, mapper) {
+        var _a;
+        const augmentDecoratorNodes = (_a = augmentDecoratorsForSym.get(sym)) !== null && _a !== void 0 ? _a : [];
+        const decorators = [];
+        for (const decNode of augmentDecoratorNodes) {
+            const decorator = checkDecorator(targetType, decNode, mapper);
+            if (decorator) {
+                decorators.unshift(decorator);
+            }
+        }
+        return decorators;
+    }
     function checkDecorators(targetType, node, mapper) {
         var _a, _b;
         const sym = isMemberNode(node) ? (_a = getSymbolForMember(node)) !== null && _a !== void 0 ? _a : node.symbol : node.symbol;
@@ -2413,7 +2499,7 @@ export function createChecker(program) {
         if (docComment) {
             decorators.unshift({
                 decorator: $docFromComment,
-                args: [{ value: program.checker.createLiteralType(docComment), jsValue: docComment }],
+                args: [{ value: createLiteralType(docComment), jsValue: docComment }],
             });
         }
         return decorators;
@@ -2435,6 +2521,7 @@ export function createChecker(program) {
             // we're not instantiating this model and we've already checked it
             return links.declaredType;
         }
+        checkTemplateDeclaration(node, mapper);
         const decorators = [];
         const type = createType({
             kind: "Scalar",
@@ -2448,7 +2535,7 @@ export function createChecker(program) {
         if (node.extends) {
             type.baseScalar = checkScalarExtends(node, node.extends, mapper);
             if (type.baseScalar) {
-                checkDeprecated(type.baseScalar, node.extends);
+                copyDeprecation(type.baseScalar, type);
                 type.baseScalar.derivedScalars.push(type);
             }
         }
@@ -2499,6 +2586,7 @@ export function createChecker(program) {
         if (links.declaredType && mapper === undefined) {
             return links.declaredType;
         }
+        checkTemplateDeclaration(node, mapper);
         const aliasSymId = getNodeSymId(node);
         if (pendingResolutions.has(aliasSymId)) {
             if (mapper === undefined) {
@@ -2544,7 +2632,7 @@ export function createChecker(program) {
                     enumType.members.set(memberType.name, memberType);
                 }
                 else {
-                    const members = checkEnumSpreadMember(enumType, member.target, mapper, memberNames);
+                    const members = checkEnumSpreadMember(node.symbol, enumType, member.target, mapper, memberNames);
                     for (const memberType of members) {
                         linkIndirectMember(node, memberType, mapper);
                         enumType.members.set(memberType.name, memberType);
@@ -2567,6 +2655,7 @@ export function createChecker(program) {
             // we're not instantiating this interface and we've already checked it
             return links.declaredType;
         }
+        checkTemplateDeclaration(node, mapper);
         const interfaceType = createType({
             kind: "Interface",
             decorators: [],
@@ -2593,11 +2682,15 @@ export function createChecker(program) {
                         target: extendsNode,
                     }));
                 }
-                const newMember = cloneType(member, { interface: interfaceType });
+                const newMember = cloneTypeForSymbol(getMemberSymbol(node.symbol, member.name), member, {
+                    interface: interfaceType,
+                });
                 // Don't link it it is overritten
                 if (!ownMembers.has(member.name)) {
                     linkIndirectMember(node, newMember, mapper);
                 }
+                // Clone deprecation information
+                copyDeprecation(member, newMember);
                 interfaceType.operations.set(newMember.name, newMember);
             }
             interfaceType.sourceInterfaces.push(extendsType);
@@ -2639,6 +2732,7 @@ export function createChecker(program) {
             // we're not instantiating this union and we've already checked it
             return links.declaredType;
         }
+        checkTemplateDeclaration(node, mapper);
         const variants = createRekeyableMap();
         const unionType = createType({
             kind: "Union",
@@ -2685,7 +2779,7 @@ export function createChecker(program) {
             // we're not instantiating this union variant and we've already checked it
             return links.declaredType;
         }
-        const name = variantNode.id.sv;
+        const name = variantNode.id ? variantNode.id.sv : Symbol("name");
         const type = getTypeForNode(variantNode.value, mapper);
         const variantType = createType({
             kind: "UnionVariant",
@@ -2711,8 +2805,14 @@ export function createChecker(program) {
             node.kind === SyntaxKind.OperationStatement ||
             node.kind === SyntaxKind.UnionVariant);
     }
+    function getMemberSymbol(parentSym, name) {
+        return parentSym ? getOrCreateAugmentedSymbolTable(parentSym.members).get(name) : undefined;
+    }
     function getSymbolForMember(node) {
         var _a;
+        if (!node.id) {
+            return undefined;
+        }
         const name = node.id.sv;
         const parentSym = (_a = node.parent) === null || _a === void 0 ? void 0 : _a.symbol;
         return parentSym ? getOrCreateAugmentedSymbolTable(parentSym.members).get(name) : undefined;
@@ -2743,7 +2843,7 @@ export function createChecker(program) {
         member.decorators = checkDecorators(member, node, mapper);
         return finishType(member);
     }
-    function checkEnumSpreadMember(parentEnum, targetNode, mapper, existingMemberNames) {
+    function checkEnumSpreadMember(parentEnumSym, parentEnum, targetNode, mapper, existingMemberNames) {
         const members = [];
         const targetType = getTypeForNode(targetNode, mapper);
         if (!isErrorType(targetType)) {
@@ -2761,7 +2861,8 @@ export function createChecker(program) {
                 }
                 else {
                     existingMemberNames.add(member.name);
-                    const clonedMember = cloneType(member, {
+                    const memberSym = getMemberSymbol(parentEnumSym, member.name);
+                    const clonedMember = cloneTypeForSymbol(memberSym, member, {
                         enum: parentEnum,
                         sourceMember: member,
                     });
@@ -2773,6 +2874,29 @@ export function createChecker(program) {
         }
         return members;
     }
+    function checkDirectives(node, type) {
+        var _a;
+        let hasDeprecation = false;
+        ((_a = node.directives) !== null && _a !== void 0 ? _a : []).forEach((directive) => {
+            if (directive.target.sv === "deprecated") {
+                if (directive.arguments[0].kind !== SyntaxKind.StringLiteral) {
+                    reportCheckerDiagnostic(createDiagnostic({
+                        code: "invalid-deprecation-argument",
+                        target: directive.arguments[0],
+                    }));
+                }
+                if (hasDeprecation === true) {
+                    reportCheckerDiagnostic(createDiagnostic({ code: "duplicate-deprecation", target: node }));
+                }
+                else {
+                    hasDeprecation = true;
+                    markDeprecated(program, type, {
+                        message: directive.arguments[0].value,
+                    });
+                }
+            }
+        });
+    }
     // the types here aren't ideal and could probably be refactored.
     function createAndFinishType(typeDef) {
         createType(typeDef);
@@ -2786,7 +2910,13 @@ export function createChecker(program) {
     function createType(typeDef) {
         Object.setPrototypeOf(typeDef, typePrototype);
         typeDef.isFinished = false;
-        return typeDef;
+        // If the type has an associated syntax node, check any directives that
+        // might be attached.
+        const createdType = typeDef;
+        if (createdType.node) {
+            checkDirectives(createdType.node, createdType);
+        }
+        return createdType;
     }
     function finishType(typeDef) {
         return finishTypeForProgramAndChecker(program, typePrototype, typeDef);
@@ -2921,23 +3051,7 @@ export function createChecker(program) {
         getSymbolLinks(globalNamespaceNode.symbol).type = type;
         return type;
     }
-    /**
-     * Clone a type, resulting in an identical type with all the same decorators
-     * applied. Decorators are re-run on the clone to achieve this.
-     *
-     * Care is taken to clone nested data structures that are part of the type.
-     * Any type with e.g. a map or an array property must recreate the map or array
-     * so that clones don't share the same object.
-     *
-     * For types which have sub-types that are part of it, e.g. enums with members,
-     * unions with variants, or models with properties, the sub-types are cloned
-     * as well.
-     *
-     * If the entire type graph needs to be cloned, then cloneType must be called
-     * recursively by the caller.
-     */
-    function cloneType(type, additionalProps = {}) {
-        // TODO: this needs to handle other types
+    function initializeClone(type, additionalProps) {
         let clone;
         switch (type.kind) {
             case "Model":
@@ -2953,7 +3067,7 @@ export function createChecker(program) {
                         cloneType(prop, { model: newModel }),
                     ]));
                 }
-                clone = finishType(newModel);
+                clone = newModel;
                 break;
             case "Union":
                 const newUnion = createType({
@@ -2971,7 +3085,7 @@ export function createChecker(program) {
                         cloneType(prop, { union: newUnion }),
                     ]));
                 }
-                clone = finishType(newUnion);
+                clone = newUnion;
                 break;
             case "Interface":
                 const newInterface = createType({
@@ -2986,7 +3100,7 @@ export function createChecker(program) {
                         cloneType(prop, { interface: newInterface }),
                     ]));
                 }
-                clone = finishType(newInterface);
+                clone = newInterface;
                 break;
             case "Enum":
                 const newEnum = createType({
@@ -3001,16 +3115,35 @@ export function createChecker(program) {
                         cloneType(prop, { enum: newEnum }),
                     ]));
                 }
-                clone = finishType(newEnum);
+                clone = newEnum;
                 break;
             default:
-                clone = createAndFinishType({
+                clone = createType({
                     ...type,
                     ...("decorators" in type ? { decorators: [...type.decorators] } : {}),
                     ...additionalProps,
                 });
                 break;
         }
+        return clone;
+    }
+    /**
+     * Clone a type, resulting in an identical type with all the same decorators
+     * applied. Decorators are re-run on the clone to achieve this.
+     *
+     * Care is taken to clone nested data structures that are part of the type.
+     * Any type with e.g. a map or an array property must recreate the map or array
+     * so that clones don't share the same object.
+     *
+     * For types which have sub-types that are part of it, e.g. enums with members,
+     * unions with variants, or models with properties, the sub-types are cloned
+     * as well.
+     *
+     * If the entire type graph needs to be cloned, then cloneType must be called
+     * recursively by the caller.
+     */
+    function cloneType(type, additionalProps = {}) {
+        const clone = finishType(initializeClone(type, additionalProps));
         const projection = projectionsByType.get(type);
         if (projection) {
             projectionsByType.set(clone, projection);
@@ -3018,6 +3151,24 @@ export function createChecker(program) {
         compilerAssert(clone.kind === type.kind, "cloneType must not change type kind");
         return clone;
     }
+    /**
+     * Clone a type linking to the given symbol.
+     * @param sym Symbol which to associate the clone
+     * @param type Type to clone
+     * @param additionalProps Additional properties to set/override on the clone
+     * @returns cloned type
+     */
+    function cloneTypeForSymbol(sym, type, additionalProps = {}) {
+        let clone = initializeClone(type, additionalProps);
+        if ("decorators" in clone) {
+            for (const dec of checkAugmentDecorators(sym, clone, undefined)) {
+                clone.decorators.push(dec);
+            }
+        }
+        clone = finishType(clone);
+        compilerAssert(clone.kind === type.kind, "cloneType must not change type kind");
+        return clone;
+    }
     function checkProjectionDeclaration(node) {
         // todo: check for duplicate projection decls on individual types
         // right now you can declare the same projection on a specific type
@@ -4250,8 +4401,19 @@ function finishTypeForProgramAndChecker(program, typePrototype, typeDef) {
     typeDef.isFinished = true;
     return typeDef;
 }
+function reportDeprecation(program, target, message, reportFunc) {
+    if (program.compilerOptions.ignoreDeprecated !== true) {
+        reportFunc(createDiagnostic({
+            code: "deprecated",
+            format: {
+                message,
+            },
+            target,
+        }));
+    }
+}
 function applyDecoratorToType(program, decApp, target) {
-    var _a;
+    var _a, _b;
     compilerAssert("decorators" in target, "Cannot apply decorator to non-decoratable type", target);
     for (const arg of decApp.args) {
         if (isErrorType(arg.value)) {
@@ -4259,6 +4421,13 @@ function applyDecoratorToType(program, decApp, target) {
             return;
         }
     }
+    // Is the decorator definition deprecated?
+    if (decApp.definition) {
+        const deprecation = getDeprecationDetails(program, decApp.definition);
+        if (deprecation !== undefined) {
+            reportDeprecation(program, (_a = decApp.node) !== null && _a !== void 0 ? _a : target, deprecation.message, program.reportDiagnostic);
+        }
+    }
     // peel `fn` off to avoid setting `this`.
     try {
         const args = decApp.args.map((x) => x.jsValue);
@@ -4272,7 +4441,7 @@ function applyDecoratorToType(program, decApp, target) {
             program.reportDiagnostic(createDiagnostic({
                 code: "decorator-fail",
                 format: { decoratorName: decApp.decorator.name, error: error.stack },
-                target: (_a = decApp.node) !== null && _a !== void 0 ? _a : target,
+                target: (_b = decApp.node) !== null && _b !== void 0 ? _b : target,
             }));
         }
         else {