@typespec/compiler 0.48.0-dev.9 → 0.48.1

package/dist/src/core/checker.js

@@ -1,3 +1,9 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PendingResolutions_data;
 import { $docFromComment, getIndexer } from "../lib/decorators.js";
 import { createSymbol, createSymbolTable } from "./binder.js";
 import { getDeprecationDetails, markDeprecated } from "./deprecation.js";
@@ -63,7 +69,7 @@ export function createChecker(program) {
      * Set keeping track of node pending type resolution.
      * Key is the SymId of a node. It can be retrieved with getNodeSymId(node)
      */
-    const pendingResolutions = new Set();
+    const pendingResolutions = new PendingResolutions();
     for (const file of program.jsSourceFiles.values()) {
         mergeSourceFile(file);
     }
@@ -342,6 +348,7 @@ export function createChecker(program) {
             case SyntaxKind.UnionVariant:
                 return checkUnionVariant(node, mapper);
             case SyntaxKind.NamespaceStatement:
+            case SyntaxKind.JsNamespaceDeclaration:
                 return checkNamespace(node);
             case SyntaxKind.OperationStatement:
                 return checkOperation(node, mapper);
@@ -987,12 +994,14 @@ export function createChecker(program) {
         if (!type) {
             type = initializeTypeForNamespace(node);
         }
-        if (isArray(node.statements)) {
-            node.statements.forEach((x) => getTypeForNode(x));
-        }
-        else if (node.statements) {
-            const subNs = checkNamespace(node.statements);
-            type.namespaces.set(subNs.name, subNs);
+        if (node.kind === SyntaxKind.NamespaceStatement) {
+            if (isArray(node.statements)) {
+                node.statements.forEach((x) => getTypeForNode(x));
+            }
+            else if (node.statements) {
+                const subNs = checkNamespace(node.statements);
+                type.namespaces.set(subNs.name, subNs);
+            }
         }
         return type;
     }
@@ -1008,7 +1017,7 @@ export function createChecker(program) {
                 kind: "Namespace",
                 name,
                 namespace,
-                node,
+                node: node,
                 models: new Map(),
                 scalars: new Map(),
                 operations: new Map(),
@@ -1074,7 +1083,7 @@ export function createChecker(program) {
             // However, one case where this is not true is when a decorator on a namespace
             // refers to a model in another namespace. In this case, we need to evaluate
             // the namespace here.
-            const namespaceNode = mergedSymbol.declarations.find((x) => x.kind === SyntaxKind.NamespaceStatement);
+            const namespaceNode = mergedSymbol.declarations.find((x) => x.kind === SyntaxKind.NamespaceStatement || x.kind === SyntaxKind.JsNamespaceDeclaration);
             compilerAssert(namespaceNode, "Can't find namespace declaration node.", node);
             symbolLinks.type = initializeTypeForNamespace(namespaceNode);
         }
@@ -1172,14 +1181,14 @@ export function createChecker(program) {
         // Ensure that we don't end up with a circular reference to the same operation
         const opSymId = getNodeSymId(operation);
         if (opSymId) {
-            pendingResolutions.add(opSymId);
+            pendingResolutions.start(opSymId, ResolutionKind.BaseType);
         }
         const target = resolveTypeReferenceSym(opReference, mapper);
         if (target === undefined) {
             return undefined;
         }
         // Did we encounter a circular operation reference?
-        if (pendingResolutions.has(getNodeSymId(target.declarations[0]))) {
+        if (pendingResolutions.has(getNodeSymId(target.declarations[0]), ResolutionKind.BaseType)) {
             if (mapper === undefined) {
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "circular-op-signature",
@@ -1192,7 +1201,7 @@ export function createChecker(program) {
         // Resolve the base operation type
         const baseOperation = checkTypeReferenceSymbol(target, opReference, mapper);
         if (opSymId) {
-            pendingResolutions.delete(opSymId);
+            pendingResolutions.finish(opSymId, ResolutionKind.BaseType);
         }
         if (isErrorType(baseOperation)) {
             return undefined;
@@ -1645,7 +1654,7 @@ export function createChecker(program) {
             default:
                 // get the symbol from the node aliased type's node, or just return the base
                 // if it doesn't have a symbol (which will likely result in an error later on)
-                return (_a = aliasType.node.symbol) !== null && _a !== void 0 ? _a : aliasSymbol;
+                return (_a = getMergedSymbol(aliasType.node.symbol)) !== null && _a !== void 0 ? _a : aliasSymbol;
         }
     }
     function checkStringLiteral(str) {
@@ -2150,12 +2159,12 @@ export function createChecker(program) {
             return undefined;
         }
         const modelSymId = getNodeSymId(model);
-        pendingResolutions.add(modelSymId);
+        pendingResolutions.start(modelSymId, ResolutionKind.BaseType);
         const target = resolveTypeReferenceSym(heritageRef, mapper);
         if (target === undefined) {
             return undefined;
         }
-        if (pendingResolutions.has(getNodeSymId(target.declarations[0]))) {
+        if (pendingResolutions.has(getNodeSymId(target.declarations[0]), ResolutionKind.BaseType)) {
             if (mapper === undefined) {
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "circular-base-type",
@@ -2166,7 +2175,7 @@ export function createChecker(program) {
             return undefined;
         }
         const heritageType = checkTypeReferenceSymbol(target, heritageRef, mapper);
-        pendingResolutions.delete(modelSymId);
+        pendingResolutions.finish(modelSymId, ResolutionKind.BaseType);
         if (isErrorType(heritageType)) {
             compilerAssert(program.hasError(), "Should already have reported an error.", heritageRef);
             return undefined;
@@ -2188,7 +2197,7 @@ export function createChecker(program) {
         if (!isExpr)
             return undefined;
         const modelSymId = getNodeSymId(model);
-        pendingResolutions.add(modelSymId);
+        pendingResolutions.start(modelSymId, ResolutionKind.BaseType);
         let isType;
         if (isExpr.kind === SyntaxKind.ModelExpression) {
             reportCheckerDiagnostic(createDiagnostic({
@@ -2206,7 +2215,7 @@ export function createChecker(program) {
             if (target === undefined) {
                 return undefined;
             }
-            if (pendingResolutions.has(getNodeSymId(target.declarations[0]))) {
+            if (pendingResolutions.has(getNodeSymId(target.declarations[0]), ResolutionKind.BaseType)) {
                 if (mapper === undefined) {
                     reportCheckerDiagnostic(createDiagnostic({
                         code: "circular-base-type",
@@ -2222,7 +2231,7 @@ export function createChecker(program) {
             reportCheckerDiagnostic(createDiagnostic({ code: "is-model", target: isExpr }));
             return undefined;
         }
-        pendingResolutions.delete(modelSymId);
+        pendingResolutions.finish(modelSymId, ResolutionKind.BaseType);
         if (isType.kind !== "Model") {
             reportCheckerDiagnostic(createDiagnostic({ code: "is-model", target: isExpr }));
             return;
@@ -2276,24 +2285,35 @@ export function createChecker(program) {
     }
     function checkModelProperty(prop, mapper) {
         var _a, _b, _c;
+        const symId = getSymbolId(getSymbolForMember(prop));
         const links = getSymbolLinksForMember(prop);
         if (links && links.declaredType && mapper === undefined) {
             return links.declaredType;
         }
         const name = prop.id.sv;
-        const valueType = getTypeForNode(prop.value, mapper);
-        const defaultValue = prop.default && checkDefault(prop.default, valueType);
         const type = createType({
             kind: "ModelProperty",
             name,
             node: prop,
             optional: prop.optional,
-            type: valueType,
+            type: undefined,
             decorators: [],
-            default: defaultValue,
         });
-        if (links) {
-            linkType(links, type, mapper);
+        if (pendingResolutions.has(symId, ResolutionKind.Type) && mapper === undefined) {
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "circular-prop",
+                format: { propName: name },
+                target: prop,
+            }));
+            type.type = errorType;
+        }
+        else {
+            pendingResolutions.start(symId, ResolutionKind.Type);
+            type.type = getTypeForNode(prop.value, mapper);
+            type.default = prop.default && checkDefault(prop.default, type.type);
+            if (links) {
+                linkType(links, type, mapper);
+            }
         }
         type.decorators = checkDecorators(type, prop, mapper);
         const parentTemplate = getParentTemplateNode(prop);
@@ -2311,6 +2331,7 @@ export function createChecker(program) {
             }
             finishType(type);
         }
+        pendingResolutions.finish(symId, ResolutionKind.Type);
         return type;
     }
     function isValueType(type) {
@@ -2566,12 +2587,12 @@ export function createChecker(program) {
     }
     function checkScalarExtends(scalar, extendsRef, mapper) {
         const symId = getNodeSymId(scalar);
-        pendingResolutions.add(symId);
+        pendingResolutions.start(symId, ResolutionKind.BaseType);
         const target = resolveTypeReferenceSym(extendsRef, mapper);
         if (target === undefined) {
             return undefined;
         }
-        if (pendingResolutions.has(getNodeSymId(target.declarations[0]))) {
+        if (pendingResolutions.has(getNodeSymId(target.declarations[0]), ResolutionKind.BaseType)) {
             if (mapper === undefined) {
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "circular-base-type",
@@ -2582,7 +2603,7 @@ export function createChecker(program) {
             return undefined;
         }
         const extendsType = checkTypeReferenceSymbol(target, extendsRef, mapper);
-        pendingResolutions.delete(symId);
+        pendingResolutions.finish(symId, ResolutionKind.BaseType);
         if (isErrorType(extendsType)) {
             compilerAssert(program.hasError(), "Should already have reported an error.", extendsRef);
             return undefined;
@@ -2600,7 +2621,7 @@ export function createChecker(program) {
         }
         checkTemplateDeclaration(node, mapper);
         const aliasSymId = getNodeSymId(node);
-        if (pendingResolutions.has(aliasSymId)) {
+        if (pendingResolutions.has(aliasSymId, ResolutionKind.Type)) {
             if (mapper === undefined) {
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "circular-alias-type",
@@ -2611,10 +2632,10 @@ export function createChecker(program) {
             links.declaredType = errorType;
             return errorType;
         }
-        pendingResolutions.add(aliasSymId);
+        pendingResolutions.start(aliasSymId, ResolutionKind.Type);
         const type = getTypeForNode(node.value, mapper);
         linkType(links, type, mapper);
-        pendingResolutions.delete(aliasSymId);
+        pendingResolutions.finish(aliasSymId, ResolutionKind.Type);
         return type;
     }
     function checkEnum(node, mapper) {
@@ -3794,42 +3815,55 @@ export function createChecker(program) {
      * @param diagnosticTarget Target for the diagnostic, unless something better can be inferred.
      */
     function isTypeAssignableTo(source, target, diagnosticTarget) {
+        const [related, diagnostics] = isTypeAssignableToInternal(source, target, diagnosticTarget, new MultiKeyMap());
+        return [related === Related.true, diagnostics];
+    }
+    function isTypeAssignableToInternal(source, target, diagnosticTarget, relationCache) {
+        const cached = relationCache.get([source, target]);
+        if (cached !== undefined) {
+            return [cached, []];
+        }
+        const [result, diagnostics] = isTypeAssignableToWorker(source, target, diagnosticTarget, new MultiKeyMap());
+        relationCache.set([source, target], result);
+        return [result, diagnostics];
+    }
+    function isTypeAssignableToWorker(source, target, diagnosticTarget, relationCache) {
         var _a;
         // BACKCOMPAT: Added May 2023 sprint, to be removed by June 2023 sprint
         if (source.kind === "TemplateParameter" && source.constraint && target.kind === "Value") {
-            const [assignable] = isTypeAssignableTo(source.constraint, target.target, diagnosticTarget);
+            const [assignable] = isTypeAssignableToInternal(source.constraint, target.target, diagnosticTarget, relationCache);
             if (assignable) {
                 const constraint = getTypeName(source.constraint);
                 reportDeprecated(program, `Template constrainted to '${constraint}' will not be assignable to '${getTypeName(target)}' in the future. Update the constraint to be 'valueof ${constraint}'`, diagnosticTarget);
-                return [true, []];
+                return [Related.true, []];
             }
         }
         if (source.kind === "TemplateParameter") {
             source = (_a = source.constraint) !== null && _a !== void 0 ? _a : unknownType;
         }
         if (source === target)
-            return [true, []];
+            return [Related.true, []];
         if (target.kind === "Value") {
-            return isAssignableToValueType(source, target, diagnosticTarget);
+            return isAssignableToValueType(source, target, diagnosticTarget, relationCache);
         }
         if (source.kind === "Value") {
-            return [false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
+            return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
         }
         const isSimpleTypeRelated = isSimpleTypeAssignableTo(source, target);
         if (isSimpleTypeRelated === true) {
-            return [true, []];
+            return [Related.true, []];
         }
         else if (isSimpleTypeRelated === false) {
-            return [false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
+            return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
         }
         if (source.kind === "Union") {
             for (const variant of source.variants.values()) {
-                const [variantAssignable] = isTypeAssignableTo(variant.type, target, diagnosticTarget);
+                const [variantAssignable] = isTypeAssignableToInternal(variant.type, target, diagnosticTarget, relationCache);
                 if (!variantAssignable) {
-                    return [false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
+                    return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
                 }
             }
-            return [true, []];
+            return [Related.true, []];
         }
         if (target.kind === "Model" &&
             source.kind === "Model" &&
@@ -3838,7 +3872,7 @@ export function createChecker(program) {
             source.indexer &&
             source.indexer.key.name === "integer") {
             return [
-                false,
+                Related.false,
                 [
                     createDiagnostic({
                         code: "missing-index",
@@ -3852,43 +3886,43 @@ export function createChecker(program) {
             ];
         }
         else if (target.kind === "Model" && target.indexer !== undefined && source.kind === "Model") {
-            return isIndexerValid(source, target, diagnosticTarget);
+            return isIndexerValid(source, target, diagnosticTarget, relationCache);
         }
         else if (target.kind === "Model" && source.kind === "Model") {
-            return isModelRelatedTo(source, target, diagnosticTarget);
+            return isModelRelatedTo(source, target, diagnosticTarget, relationCache);
         }
         else if (target.kind === "Model" && target.indexer && source.kind === "Tuple") {
             for (const item of source.values) {
-                const [related, diagnostics] = isTypeAssignableTo(item, target.indexer.value, diagnosticTarget);
+                const [related, diagnostics] = isTypeAssignableToInternal(item, target.indexer.value, diagnosticTarget, relationCache);
                 if (!related) {
-                    return [false, diagnostics];
+                    return [Related.false, diagnostics];
                 }
             }
-            return [true, []];
+            return [Related.true, []];
         }
         else if (target.kind === "Tuple" && source.kind === "Tuple") {
-            return isTupleAssignableToTuple(source, target, diagnosticTarget);
+            return isTupleAssignableToTuple(source, target, diagnosticTarget, relationCache);
         }
         else if (target.kind === "Union") {
-            return isAssignableToUnion(source, target, diagnosticTarget);
+            return isAssignableToUnion(source, target, diagnosticTarget, relationCache);
         }
         else if (target.kind === "Enum") {
             return isAssignableToEnum(source, target, diagnosticTarget);
         }
-        return [false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
+        return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
     }
-    function isAssignableToValueType(source, target, diagnosticTarget) {
+    function isAssignableToValueType(source, target, diagnosticTarget, relationCache) {
         if (source.kind === "Value") {
-            return isTypeAssignableTo(source.target, target.target, diagnosticTarget);
+            return isTypeAssignableToInternal(source.target, target.target, diagnosticTarget, relationCache);
         }
-        const [assignable, diagnostics] = isTypeAssignableTo(source, target.target, diagnosticTarget);
+        const [assignable, diagnostics] = isTypeAssignableToInternal(source, target.target, diagnosticTarget, relationCache);
         if (!assignable) {
             return [assignable, diagnostics];
         }
         if (!isValueType(source)) {
-            return [false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
+            return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
         }
-        return [true, []];
+        return [Related.true, []];
     }
     function isReflectionType(type) {
         var _a, _b, _c;
@@ -3971,7 +4005,8 @@ export function createChecker(program) {
         const [low, high, options] = numericRanges[target.name];
         return source.value >= low && source.value <= high && (!options.int || isInt);
     }
-    function isModelRelatedTo(source, target, diagnosticTarget) {
+    function isModelRelatedTo(source, target, diagnosticTarget, relationCache) {
+        relationCache.set([source, target], Related.maybe);
         const diagnostics = [];
         for (const prop of walkPropertiesInherited(target)) {
             const sourceProperty = getProperty(source, prop.name);
@@ -3989,27 +4024,27 @@ export function createChecker(program) {
                 }
             }
             else {
-                const [related, propDiagnostics] = isTypeAssignableTo(sourceProperty.type, prop.type, diagnosticTarget);
+                const [related, propDiagnostics] = isTypeAssignableToInternal(sourceProperty.type, prop.type, diagnosticTarget, relationCache);
                 if (!related) {
                     diagnostics.push(...propDiagnostics);
                 }
             }
         }
-        return [diagnostics.length === 0, diagnostics];
+        return [diagnostics.length === 0 ? Related.true : Related.false, diagnostics];
     }
     function getProperty(model, name) {
         var _a;
         return ((_a = model.properties.get(name)) !== null && _a !== void 0 ? _a : (model.baseModel !== undefined ? getProperty(model.baseModel, name) : undefined));
     }
-    function isIndexerValid(source, target, diagnosticTarget) {
+    function isIndexerValid(source, target, diagnosticTarget, relationCache) {
         // Model expressions should be able to be assigned.
         if (source.name === "" && target.indexer.key.name !== "integer") {
-            return isIndexConstraintValid(target.indexer.value, source, diagnosticTarget);
+            return isIndexConstraintValid(target.indexer.value, source, diagnosticTarget, relationCache);
         }
         else {
             if (source.indexer === undefined || source.indexer.key !== target.indexer.key) {
                 return [
-                    false,
+                    Related.false,
                     [
                         createDiagnostic({
                             code: "missing-index",
@@ -4022,7 +4057,7 @@ export function createChecker(program) {
                     ],
                 ];
             }
-            return isTypeAssignableTo(source.indexer.value, target.indexer.value, diagnosticTarget);
+            return isTypeAssignableToInternal(source.indexer.value, target.indexer.value, diagnosticTarget, relationCache);
         }
     }
     /**
@@ -4030,25 +4065,25 @@ export function createChecker(program) {
      * @param type Type of the model that should be respecting the constraint.
      * @param diagnosticTarget Diagnostic target unless something better can be inferred.
      */
-    function isIndexConstraintValid(constraintType, type, diagnosticTarget) {
+    function isIndexConstraintValid(constraintType, type, diagnosticTarget, relationCache) {
         for (const prop of type.properties.values()) {
             const [related, diagnostics] = isTypeAssignableTo(prop.type, constraintType, diagnosticTarget);
             if (!related) {
-                return [false, diagnostics];
+                return [Related.false, diagnostics];
             }
         }
         if (type.baseModel) {
-            const [related, diagnostics] = isIndexConstraintValid(constraintType, type.baseModel, diagnosticTarget);
+            const [related, diagnostics] = isIndexConstraintValid(constraintType, type.baseModel, diagnosticTarget, relationCache);
             if (!related) {
-                return [false, diagnostics];
+                return [Related.false, diagnostics];
             }
         }
-        return [true, []];
+        return [Related.true, []];
     }
-    function isTupleAssignableToTuple(source, target, diagnosticTarget) {
+    function isTupleAssignableToTuple(source, target, diagnosticTarget, relationCache) {
         if (source.values.length !== target.values.length) {
             return [
-                false,
+                Related.false,
                 [
                     createDiagnostic({
                         code: "unassignable",
@@ -4065,40 +4100,40 @@ export function createChecker(program) {
         }
         for (const [index, sourceItem] of source.values.entries()) {
             const targetItem = target.values[index];
-            const [related, diagnostics] = isTypeAssignableTo(sourceItem, targetItem, diagnosticTarget);
+            const [related, diagnostics] = isTypeAssignableToInternal(sourceItem, targetItem, diagnosticTarget, relationCache);
             if (!related) {
-                return [false, diagnostics];
+                return [Related.false, diagnostics];
             }
         }
-        return [true, []];
+        return [Related.true, []];
     }
-    function isAssignableToUnion(source, target, diagnosticTarget) {
+    function isAssignableToUnion(source, target, diagnosticTarget, relationCache) {
         for (const option of target.variants.values()) {
-            const [related] = isTypeAssignableTo(source, option.type, diagnosticTarget);
+            const [related] = isTypeAssignableToInternal(source, option.type, diagnosticTarget, relationCache);
             if (related) {
-                return [true, []];
+                return [Related.true, []];
             }
         }
-        return [false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
+        return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
     }
     function isAssignableToEnum(source, target, diagnosticTarget) {
         switch (source.kind) {
             case "Enum":
                 if (source === target) {
-                    return [true, []];
+                    return [Related.true, []];
                 }
                 else {
-                    return [false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
+                    return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
                 }
             case "EnumMember":
                 if (source.enum === target) {
-                    return [true, []];
+                    return [Related.true, []];
                 }
                 else {
-                    return [false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
+                    return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
                 }
             default:
-                return [false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
+                return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
         }
     }
     function createUnassignableDiagnostic(source, target, diagnosticTarget) {
@@ -4519,4 +4554,43 @@ const ReflectionNameToKind = {
     UnionVariant: "UnionVariant",
 };
 const _assertReflectionNameToKind = ReflectionNameToKind;
+var ResolutionKind;
+(function (ResolutionKind) {
+    ResolutionKind[ResolutionKind["Type"] = 0] = "Type";
+    ResolutionKind[ResolutionKind["BaseType"] = 1] = "BaseType";
+})(ResolutionKind || (ResolutionKind = {}));
+class PendingResolutions {
+    constructor() {
+        _PendingResolutions_data.set(this, new Map());
+    }
+    start(symId, kind) {
+        let existing = __classPrivateFieldGet(this, _PendingResolutions_data, "f").get(symId);
+        if (existing === undefined) {
+            existing = new Set();
+            __classPrivateFieldGet(this, _PendingResolutions_data, "f").set(symId, existing);
+        }
+        existing.add(kind);
+    }
+    has(symId, kind) {
+        var _a, _b;
+        return (_b = (_a = __classPrivateFieldGet(this, _PendingResolutions_data, "f").get(symId)) === null || _a === void 0 ? void 0 : _a.has(kind)) !== null && _b !== void 0 ? _b : false;
+    }
+    finish(symId, kind) {
+        const existing = __classPrivateFieldGet(this, _PendingResolutions_data, "f").get(symId);
+        if (existing === undefined) {
+            return;
+        }
+        existing === null || existing === void 0 ? void 0 : existing.delete(kind);
+        if (existing.size === 0) {
+            __classPrivateFieldGet(this, _PendingResolutions_data, "f").delete(symId);
+        }
+    }
+}
+_PendingResolutions_data = new WeakMap();
+var Related;
+(function (Related) {
+    Related[Related["false"] = 0] = "false";
+    Related[Related["true"] = 1] = "true";
+    Related[Related["maybe"] = 2] = "maybe";
+})(Related || (Related = {}));
 //# sourceMappingURL=checker.js.map