@typespec/compiler 1.3.0-dev.10 → 1.3.0-dev.11

package/dist/src/core/checker.js

@@ -25,6 +25,7 @@ import { IdentifierKind, ResolutionResultFlags, SyntaxKind, } from "./types.js";
 const TypeInstantiationMap = class extends MultiKeyMap {
 };
 export function createChecker(program, resolver) {
+    const waitingForResolution = new Map();
     const stats = {
         createdTypes: 0,
         finishedTypes: 0,
@@ -41,11 +42,11 @@ export function createChecker(program, resolver) {
     const globalNamespaceType = createGlobalNamespaceType();
     // Caches the deprecation test of nodes in the program
     const nodeDeprecationMap = new Map();
-    const errorType = createType({ kind: "Intrinsic", name: "ErrorType" });
-    const voidType = createType({ kind: "Intrinsic", name: "void" });
-    const neverType = createType({ kind: "Intrinsic", name: "never" });
-    const unknownType = createType({ kind: "Intrinsic", name: "unknown" });
-    const nullType = createType({ kind: "Intrinsic", name: "null" });
+    const errorType = createAndFinishType({ kind: "Intrinsic", name: "ErrorType" });
+    const voidType = createAndFinishType({ kind: "Intrinsic", name: "void" });
+    const neverType = createAndFinishType({ kind: "Intrinsic", name: "never" });
+    const unknownType = createAndFinishType({ kind: "Intrinsic", name: "unknown" });
+    const nullType = createAndFinishType({ kind: "Intrinsic", name: "null" });
     /**
      * Set keeping track of node pending type resolution.
      * Key is the SymId of a node. It can be retrieved with getNodeSymId(node)
@@ -553,6 +554,8 @@ export function createChecker(program, resolver) {
                 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);
             }
         }
@@ -1160,10 +1163,42 @@ export function createChecker(program, resolver) {
             // 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 type = mergeModelTypes(node.symbol, node, options, mapper);
-        linkType(links, type, mapper);
-        return type;
+        ensureResolved(options.map(([, type]) => type), intersection, () => {
+            const type = mergeModelTypes(node.symbol, node, options, mapper, intersection);
+            linkType(links, type, mapper);
+            finishType(intersection);
+        });
+        return intersection;
+    }
+    function ensureResolved(types, awaitingType, callback) {
+        const waitingFor = new Set();
+        for (const type of types) {
+            if (type === undefined)
+                continue;
+            if (type.creating) {
+                waitingFor.add(type);
+            }
+        }
+        function check() {
+            if (waitingFor.size === 0) {
+                callback();
+            }
+        }
+        for (const type of waitingFor) {
+            waitingForResolution.set(type, [
+                ...(waitingForResolution.get(type) || []),
+                [
+                    awaitingType,
+                    () => {
+                        waitingFor.delete(type);
+                        check();
+                    },
+                ],
+            ]);
+        }
+        check();
     }
     function checkDecoratorDeclaration(node, mapper) {
         const symbol = getMergedSymbol(node.symbol);
@@ -1268,18 +1303,8 @@ export function createChecker(program, resolver) {
                 };
         }
     }
-    function mergeModelTypes(parentModelSym, node, options, mapper) {
-        const properties = createRekeyableMap();
-        const intersection = createType({
-            kind: "Model",
-            node,
-            name: "",
-            namespace: getParentNamespaceType(node),
-            properties: properties,
-            decorators: [],
-            derivedModels: [],
-            sourceModels: [],
-        });
+    function mergeModelTypes(parentModelSym, node, options, mapper, intersection) {
+        const properties = intersection.properties;
         const indexers = [];
         const modelOptions = options.filter((entry) => {
             const [optionNode, option] = entry;
@@ -1339,7 +1364,7 @@ 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),
+                value: mergeModelTypes(undefined, node, indexers.map((x) => [x.value.node, x.value]), mapper, initModel(node)),
             };
         }
         linkMapper(intersection, mapper);
@@ -1476,7 +1501,6 @@ export function createChecker(program, resolver) {
         }
         const namespace = getParentNamespaceType(node);
         const name = node.id.sv;
-        let decorators = [];
         const { resolvedSymbol: parameterModelSym } = resolver.resolveMetaMemberByName(symbol, "parameters");
         if (parameterModelSym?.members) {
             const members = resolver.getAugmentedSymbolTable(parameterModelSym.members);
@@ -1488,78 +1512,71 @@ export function createChecker(program, resolver) {
                 }
             }
         }
-        // Is this a definition or reference?
-        let parameters, returnType, sourceOperation;
-        if (node.signature.kind === SyntaxKind.OperationSignatureReference) {
-            // Attempt to resolve the operation
-            const baseOperation = checkOperationIs(node, node.signature.baseOperation, mapper);
-            if (baseOperation) {
-                sourceOperation = baseOperation;
-                // Reference the same return type and create the parameters type
-                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];
-            }
-            else {
-                // If we can't resolve the signature we return an empty model.
-                parameters = createAndFinishType({
-                    kind: "Model",
-                    name: "",
-                    decorators: [],
-                    properties: createRekeyableMap(),
-                    derivedModels: [],
-                    sourceModels: [],
-                });
-                returnType = voidType;
-            }
-        }
-        else {
-            parameters = getTypeForNode(node.signature.parameters, mapper);
-            returnType = getTypeForNode(node.signature.returnType, mapper);
-        }
         const operationType = createType({
             kind: "Operation",
             name,
             namespace,
+            parameters: null,
+            returnType: voidType,
             node,
-            parameters,
-            returnType,
-            decorators,
-            sourceOperation,
+            decorators: [],
             interface: parentInterface,
         });
         if (links) {
             linkType(links, operationType, mapper);
         }
-        decorators.push(...checkDecorators(operationType, node, mapper));
-        operationType.parameters.namespace = namespace;
         const parent = node.parent;
-        linkMapper(operationType, mapper);
-        if (parent.kind === SyntaxKind.InterfaceStatement) {
-            if (shouldCreateTypeForTemplate(parent, mapper) &&
-                shouldCreateTypeForTemplate(node, mapper)) {
-                finishType(operationType);
-            }
+        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 });
         }
-        else {
-            if (shouldCreateTypeForTemplate(node, mapper)) {
-                finishType(operationType);
+        // 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);
+            if (baseOperation) {
+                ensureResolved([baseOperation], operationType, () => {
+                    operationType.sourceOperation = baseOperation;
+                    // Reference the same return type and create the parameters type
+                    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,
+                        }),
+                    ]));
+                    operationType.parameters = finishType(clone);
+                    operationType.returnType = baseOperation.returnType;
+                    // Copy decorators from the base operation, inserting the base decorators first
+                    operationType.decorators.push(...baseOperation.decorators);
+                    finishOperation();
+                });
             }
-            if (mapper === undefined) {
-                namespace?.operations.set(name, operationType);
+            else {
+                // If we can't resolve the signature we return an empty model.
+                operationType.parameters = initModel();
+                operationType.returnType = voidType;
+                finishOperation();
             }
         }
+        else {
+            operationType.parameters = getTypeForNode(node.signature.parameters, mapper);
+            operationType.returnType = getTypeForNode(node.signature.returnType, mapper);
+            ensureResolved([operationType.parameters], operationType, () => {
+                finishOperation();
+            });
+        }
+        linkMapper(operationType, mapper);
+        if (parent.kind !== SyntaxKind.InterfaceStatement && mapper === undefined) {
+            namespace?.operations.set(name, operationType);
+        }
         return operationType;
     }
     function checkOperationIs(operation, opReference, mapper) {
@@ -2419,6 +2436,20 @@ export function createChecker(program, resolver) {
             checkSourceFile(file);
         }
         internalDecoratorValidation();
+        assertNoPendingResolutions();
+    }
+    function assertNoPendingResolutions() {
+        if (waitingForResolution.size === 0) {
+            return;
+        }
+        const message = [
+            "Unexpected pending resolutions found",
+            ...[...waitingForResolution.entries()].flatMap(([type, items]) => {
+                const base = `  (${type.kind}) ${getTypeName(type)} => `;
+                return items.map(([item], index) => `${index === 0 ? base : " ".repeat(base.length)}${getTypeName(item)}`);
+            }),
+        ].join("\n");
+        compilerAssert(false, message);
     }
     function checkDuplicateSymbols() {
         program.reportDuplicateSymbols(resolver.symbols.global.exports);
@@ -2523,65 +2554,67 @@ export function createChecker(program, resolver) {
             }
         }
         const isBase = checkModelIs(node, node.is, mapper);
-        if (isBase) {
-            type.sourceModel = isBase;
-            type.sourceModels.push({ usage: "is", model: isBase });
-            // copy decorators
-            decorators.push(...isBase.decorators);
-            if (isBase.indexer) {
-                type.indexer = isBase.indexer;
-            }
-        }
-        if (isBase) {
-            for (const prop of isBase.properties.values()) {
-                const memberSym = getMemberSymbol(node.symbol, prop.name);
-                const newProp = cloneTypeForSymbol(memberSym, prop, {
-                    sourceProperty: prop,
-                    model: type,
-                });
-                linkIndirectMember(node, newProp, mapper);
-                type.properties.set(prop.name, newProp);
+        ensureResolved([
+            isBase,
+            ...node.properties
+                .filter((x) => x.kind === SyntaxKind.ModelSpreadProperty)
+                .map((x) => checkSpreadTarget(node, x.target, mapper)),
+        ], type, () => {
+            if (isBase) {
+                type.sourceModel = isBase;
+                type.sourceModels.push({ usage: "is", model: isBase });
+                decorators.push(...isBase.decorators);
+                if (isBase.indexer) {
+                    type.indexer = isBase.indexer;
+                }
+                for (const prop of isBase.properties.values()) {
+                    const memberSym = getMemberSymbol(node.symbol, prop.name);
+                    const newProp = cloneTypeForSymbol(memberSym, prop, {
+                        sourceProperty: prop,
+                        model: type,
+                    });
+                    linkIndirectMember(node, newProp, mapper);
+                    type.properties.set(prop.name, newProp);
+                }
+            }
+            if (isBase) {
+                type.baseModel = isBase.baseModel;
+            }
+            else if (node.extends) {
+                type.baseModel = checkClassHeritage(node, node.extends, mapper);
+                if (type.baseModel) {
+                    copyDeprecation(type.baseModel, type);
+                }
             }
-        }
-        if (isBase) {
-            type.baseModel = isBase.baseModel;
-        }
-        else if (node.extends) {
-            type.baseModel = checkClassHeritage(node, node.extends, mapper);
             if (type.baseModel) {
-                copyDeprecation(type.baseModel, type);
+                type.baseModel.derivedModels.push(type);
             }
-        }
-        if (type.baseModel) {
-            type.baseModel.derivedModels.push(type);
-        }
-        // Hold on to the model type that's being defined so that it
-        // can be referenced
-        if (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);
-        if (shouldCreateTypeForTemplate(node, mapper)) {
-            finishType(type);
-        }
-        const indexer = getIndexer(program, type);
-        if (type.name === "Array" && isInTypeSpecNamespace(type)) {
-            stdTypes.Array = type;
-        }
-        else if (type.name === "Record" && isInTypeSpecNamespace(type)) {
-            stdTypes.Record = type;
-        }
-        if (indexer) {
-            type.indexer = indexer;
-        }
-        lateBindMemberContainer(type);
-        lateBindMembers(type);
+            // Hold on to the model type that's being defined so that it
+            // can be referenced
+            if (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) });
+            lateBindMemberContainer(type);
+            lateBindMembers(type);
+            const indexer = getIndexer(program, type);
+            if (type.name === "Array" && isInTypeSpecNamespace(type)) {
+                stdTypes.Array = type;
+            }
+            else if (type.name === "Record" && isInTypeSpecNamespace(type)) {
+                stdTypes.Record = type;
+            }
+            if (indexer) {
+                type.indexer = indexer;
+            }
+        });
         return type;
     }
-    function shouldCreateTypeForTemplate(node, mapper) {
+    function shouldRunDecorators(node, mapper) {
         // Node is not a template we should create the type.
         if (node.templateParameters.length === 0) {
             return true;
@@ -2600,22 +2633,17 @@ export function createChecker(program, resolver) {
             // we're not instantiating this model and we've already checked it
             return links.declaredType;
         }
-        const properties = createRekeyableMap();
-        const type = createType({
-            kind: "Model",
-            name: "",
-            node: node,
-            properties,
-            indexer: undefined,
-            namespace: getParentNamespaceType(node),
-            decorators: [],
-            derivedModels: [],
-            sourceModels: [],
-        });
+        const type = initModel(node);
+        const properties = type.properties;
         linkType(links, type, mapper);
         linkMapper(type, mapper);
-        checkModelProperties(node, properties, type, mapper);
-        return finishType(type);
+        ensureResolved(node.properties
+            .filter((x) => x.kind === SyntaxKind.ModelSpreadProperty)
+            .map((x) => checkSpreadTarget(node, x.target, mapper)), type, () => {
+            checkModelProperties(node, properties, type, mapper);
+            finishType(type);
+        });
+        return type;
     }
     /** Find the indexer that applies to this model. Either defined on itself or from a base model */
     function findIndexer(model) {
@@ -3334,6 +3362,23 @@ export function createChecker(program, resolver) {
         }
         return isType;
     }
+    /** Get the type for the spread target */
+    function checkSpreadTarget(model, target, mapper) {
+        const modelSymId = getNodeSym(model);
+        const targetSym = resolver.getNodeLinks(target).resolvedSymbol;
+        if (targetSym === modelSymId) {
+            if (mapper === undefined) {
+                reportCheckerDiagnostic(createDiagnostic({
+                    code: "spread-model",
+                    messageId: "selfSpread",
+                    target: target,
+                }));
+            }
+            return undefined;
+        }
+        const type = getTypeForNode(target, mapper);
+        return type;
+    }
     function checkSpreadProperty(parentModelSym, targetNode, parentModel, mapper) {
         const targetType = getTypeForNode(targetNode, mapper);
         if (targetType.kind === "TemplateParameter" || isErrorType(targetType)) {
@@ -3347,13 +3392,6 @@ export function createChecker(program, resolver) {
             reportCheckerDiagnostic(createDiagnostic({ code: "spread-model", target: targetNode }), mapper);
             return [[], undefined];
         }
-        if (parentModel === targetType) {
-            reportCheckerDiagnostic(createDiagnostic({
-                code: "spread-model",
-                messageId: "selfSpread",
-                target: targetNode,
-            }));
-        }
         parentModel.sourceModels.push({ usage: "spread", model: targetType });
         const props = [];
         // copy each property
@@ -3425,15 +3463,16 @@ export function createChecker(program, resolver) {
         type.decorators = checkDecorators(type, prop, mapper);
         const parentTemplate = getParentTemplateNode(prop);
         linkMapper(type, mapper);
-        if (!parentTemplate || shouldCreateTypeForTemplate(parentTemplate, mapper)) {
+        let runDecorators = false;
+        if (!parentTemplate || shouldRunDecorators(parentTemplate, mapper)) {
             const docComment = docFromCommentForSym.get(sym);
             if (docComment) {
                 type.decorators.unshift(createDocFromCommentDecorator("self", docComment));
             }
-            finishType(type);
+            runDecorators = true;
         }
         pendingResolutions.finish(sym, ResolutionKind.Type);
-        return type;
+        return finishType(type, { skipDecorators: !runDecorators });
     }
     function createDocFromCommentDecorator(key, doc) {
         return {
@@ -3809,13 +3848,10 @@ export function createChecker(program, resolver) {
             type.namespace?.scalars.set(type.name, type);
         }
         linkMapper(type, mapper);
-        if (shouldCreateTypeForTemplate(node, mapper)) {
-            finishType(type);
-        }
         if (isInTypeSpecNamespace(type)) {
             stdTypes[type.name] = type;
         }
-        return type;
+        return finishType(type, { skipDecorators: !shouldRunDecorators(node, mapper) });
     }
     function checkScalarExtends(scalar, extendsRef, mapper) {
         const symId = getNodeSym(scalar);
@@ -3882,13 +3918,12 @@ export function createChecker(program, resolver) {
             parameters: node.parameters.map((x) => checkFunctionParameter(x, mapper, false)),
         });
         linkMapper(member, mapper);
-        if (shouldCreateTypeForTemplate(node.parent, mapper)) {
-            finishType(member);
-        }
         if (links) {
             linkType(links, member, mapper);
         }
-        return finishType(member);
+        return finishType(member, {
+            skipDecorators: !shouldRunDecorators(node.parent, mapper),
+        });
     }
     function checkAlias(node, mapper) {
         const links = getSymbolLinks(node.symbol);
@@ -4057,15 +4092,14 @@ export function createChecker(program, resolver) {
             interfaceType.operations.set(key, value);
         }
         linkMapper(interfaceType, mapper);
-        if (shouldCreateTypeForTemplate(node, mapper)) {
-            finishType(interfaceType);
-        }
         if (mapper === undefined) {
             interfaceType.namespace?.interfaces.set(interfaceType.name, interfaceType);
         }
         lateBindMemberContainer(interfaceType);
         lateBindMembers(interfaceType);
-        return interfaceType;
+        return finishType(interfaceType, {
+            skipDecorators: !shouldRunDecorators(node, mapper),
+        });
     }
     function checkInterfaceMembers(node, mapper, interfaceType) {
         const ownMembers = new Map();
@@ -4107,15 +4141,12 @@ export function createChecker(program, resolver) {
         unionType.decorators = checkDecorators(unionType, node, mapper);
         checkUnionVariants(unionType, node, variants, mapper);
         linkMapper(unionType, mapper);
-        if (shouldCreateTypeForTemplate(node, mapper)) {
-            finishType(unionType);
-        }
         if (mapper === undefined) {
             unionType.namespace?.unions.set(unionType.name, unionType);
         }
         lateBindMemberContainer(unionType);
         lateBindMembers(unionType);
-        return unionType;
+        return finishType(unionType, { skipDecorators: !shouldRunDecorators(node, mapper) });
     }
     function checkUnionVariants(parentUnion, node, variants, mapper) {
         for (const variantNode of node.options) {
@@ -4150,13 +4181,12 @@ export function createChecker(program, resolver) {
         });
         variantType.decorators = checkDecorators(variantType, variantNode, mapper);
         linkMapper(variantType, mapper);
-        if (shouldCreateTypeForTemplate(variantNode.parent, mapper)) {
-            finishType(variantType);
-        }
         if (links) {
             linkType(links, variantType, mapper);
         }
-        return variantType;
+        return finishType(variantType, {
+            skipDecorators: !shouldRunDecorators(variantNode.parent, mapper),
+        });
     }
     function isMemberNode(node) {
         return node.symbol && !!(node.symbol.flags & 65536 /* SymbolFlags.Member */);
@@ -4271,6 +4301,19 @@ export function createChecker(program, resolver) {
         createType(typeDef);
         return finishType(typeDef);
     }
+    /** Initialize model type for the given node */
+    function initModel(node) {
+        return createType({
+            kind: "Model",
+            node,
+            name: "",
+            namespace: node && getParentNamespaceType(node),
+            properties: createRekeyableMap(),
+            decorators: [],
+            derivedModels: [],
+            sourceModels: [],
+        });
+    }
     /**
      * Given the own-properties of a type, returns a fully-initialized type.
      */
@@ -4278,6 +4321,7 @@ export function createChecker(program, resolver) {
         stats.createdTypes++;
         Object.setPrototypeOf(typeDef, typePrototype);
         typeDef.isFinished = false;
+        typeDef.creating = true;
         // If the type has an associated syntax node, check any directives that
         // might be attached.
         const createdType = typeDef;
@@ -4287,9 +4331,29 @@ export function createChecker(program, resolver) {
         }
         return createdType;
     }
-    function finishType(typeDef) {
+    function finishType(typeDef, options = {}) {
         stats.finishedTypes++;
-        return finishTypeForProgramAndChecker(program, typePrototype, typeDef);
+        if (!options.skipDecorators) {
+            if ("decorators" in typeDef) {
+                for (const decApp of typeDef.decorators) {
+                    applyDecoratorToType(program, decApp, typeDef);
+                }
+            }
+            typeDef.isFinished = true;
+            Object.setPrototypeOf(typeDef, typePrototype);
+        }
+        markAsChecked(typeDef);
+        return typeDef;
+    }
+    function markAsChecked(type) {
+        if (!type.creating)
+            return;
+        delete type.creating;
+        const pending = waitingForResolution.get(type);
+        if (pending) {
+            pending.forEach(([_, resolution]) => resolution());
+        }
+        waitingForResolution.delete(type);
     }
     function getLiteralType(node) {
         return createLiteralType(node.value, node);
@@ -4412,12 +4476,9 @@ export function createChecker(program, resolver) {
      * recursively by the caller.
      */
     function cloneType(type, additionalProps = {}) {
-        let clone = initializeClone(type, additionalProps);
-        if (type.isFinished) {
-            clone = finishType(clone);
-        }
+        const clone = initializeClone(type, additionalProps);
         compilerAssert(clone.kind === type.kind, "cloneType must not change type kind");
-        return clone;
+        return finishType(clone, { skipDecorators: !type.isFinished });
     }
     /**
      * Clone a type linking to the given symbol.
@@ -4473,7 +4534,7 @@ export function createChecker(program, resolver) {
                 break;
         }
         program.literalTypes.set(value, type);
-        return type;
+        return finishType(type);
     }
     /**
      * Check if the source type can be assigned to the target type and emit diagnostics
@@ -4708,7 +4769,7 @@ export function filterModelProperties(program, model, filter) {
             typekit.type.finishType(newProperty);
         }
     }
-    return finishTypeForProgram(program, newModel);
+    return program.checker.finishType(newModel);
 }
 /**
  * Gets the property from the nearest base type that is overridden by the
@@ -4754,9 +4815,6 @@ function countPropertiesInherited(model, filter) {
     }
     return count;
 }
-export function finishTypeForProgram(program, typeDef) {
-    return finishTypeForProgramAndChecker(program, program.checker.typePrototype, typeDef);
-}
 function linkMapper(typeDef, mapper) {
     if (mapper) {
         compilerAssert(!typeDef.templateMapper, "Mapper provided but template arguments already set.");
@@ -4830,16 +4888,6 @@ function getDocContent(content) {
     }
     return docs.join("");
 }
-function finishTypeForProgramAndChecker(program, typePrototype, typeDef) {
-    if ("decorators" in typeDef) {
-        for (const decApp of typeDef.decorators) {
-            applyDecoratorToType(program, decApp, typeDef);
-        }
-    }
-    Object.setPrototypeOf(typeDef, typePrototype);
-    typeDef.isFinished = true;
-    return typeDef;
-}
 function reportDeprecation(program, target, message, reportFunc) {
     if (program.compilerOptions.ignoreDeprecated !== true) {
         reportFunc(createDiagnostic({