@typespec/compiler 0.60.0-dev.9 → 0.61.0-dev.0

package/dist/src/core/checker.js

@@ -10,14 +10,13 @@ import { validateInheritanceDiscriminatedUnions } from "./helpers/discriminator-
 import { getLocationContext } from "./helpers/location-context.js";
 import { explainStringTemplateNotSerializable } from "./helpers/string-template-utils.js";
 import { getEntityName, getNamespaceFullName, getTypeName, } from "./helpers/type-name-utils.js";
-import { getMaxItems, getMaxLength, getMaxValueAsNumeric, getMaxValueExclusiveAsNumeric, getMinItems, getMinLength, getMinValueAsNumeric, getMinValueExclusiveAsNumeric, } from "./intrinsic-type-state.js";
 import { canNumericConstraintBeJsNumber, legacyMarshallTypeForJS, marshallTypeForJS, } from "./js-marshaller.js";
 import { createDiagnostic } from "./messages.js";
-import { numericRanges } from "./numeric-ranges.js";
 import { Numeric } from "./numeric.js";
 import { exprIsBareIdentifier, getFirstAncestor, getIdentifierContext, hasParseError, visitChildren, } from "./parser.js";
 import { createProjectionMembers } from "./projection-members.js";
-import { getFullyQualifiedSymbolName, getParentTemplateNode, isArrayModelType, isErrorType, isNeverType, isNullType, isTemplateInstance, isType, isUnknownType, isValue, isVoidType, } from "./type-utils.js";
+import { createTypeRelationChecker } from "./type-relation-checker.js";
+import { getFullyQualifiedSymbolName, getParentTemplateNode, isArrayModelType, isErrorType, isNullType, isTemplateInstance, isType, isValue, } from "./type-utils.js";
 import { IdentifierKind, SyntaxKind, } from "./types.js";
 /**
  * Maps type arguments to type instantiation.
@@ -122,14 +121,16 @@ export function createChecker(program) {
         createFunctionType,
         createLiteralType,
         finishType,
-        isTypeAssignableTo,
         isStdType,
         getStdType,
         resolveTypeReference,
         getValueForNode,
         getTypeOrValueForNode,
         getValueExactType,
+        isTypeAssignableTo: undefined,
     };
+    const relation = createTypeRelationChecker(program, checker);
+    checker.isTypeAssignableTo = relation.isTypeAssignableTo;
     const projectionMembers = createProjectionMembers(checker);
     return checker;
     function reportCheckerDiagnostic(diagnostic) {
@@ -534,7 +535,8 @@ export function createChecker(program) {
     }
     function canTryLegacyCast(target, constraint) {
         return Boolean(constraint?.valueType &&
-            !(constraint.type && ignoreDiagnostics(isTypeAssignableTo(target, constraint.type, target))));
+            !(constraint.type &&
+                ignoreDiagnostics(relation.isTypeAssignableTo(target, constraint.type, target))));
     }
     /**
      * Gets a type or value depending on the node and current constraint.
@@ -1353,15 +1355,16 @@ export function createChecker(program) {
         if (marshalling === "legacy") {
             for (const param of decorator.parameters) {
                 if (param.type.valueType) {
-                    if (ignoreDiagnostics(isTypeAssignableTo(nullType, param.type.valueType, param.type))) {
+                    if (ignoreDiagnostics(relation.isTypeAssignableTo(nullType, param.type.valueType, param.type))) {
                         reportDeprecatedLegacyMarshalling(param, "null as a type");
                     }
                     else if (param.type.valueType.kind === "Enum" ||
                         param.type.valueType.kind === "EnumMember" ||
-                        (isReflectionType(param.type.valueType) && param.type.valueType.name === "EnumMember")) {
+                        (relation.isReflectionType(param.type.valueType) &&
+                            param.type.valueType.name === "EnumMember")) {
                         reportDeprecatedLegacyMarshalling(param, "enum members");
                     }
-                    else if (ignoreDiagnostics(isTypeAssignableTo(param.type.valueType, getStdType("numeric"), param.type.valueType)) &&
+                    else if (ignoreDiagnostics(relation.isTypeAssignableTo(param.type.valueType, getStdType("numeric"), param.type.valueType)) &&
                         !canNumericConstraintBeJsNumber(param.type.valueType)) {
                         reportDeprecatedLegacyMarshalling(param, "a numeric type that is not representable as a JS Number");
                     }
@@ -2918,7 +2921,7 @@ export function createChecker(program) {
             ]);
             return;
         }
-        const [valid, diagnostics] = isTypeAssignableTo(property.type, indexer.value, diagnosticTarget);
+        const [valid, diagnostics] = relation.isTypeAssignableTo(property.type, indexer.value, diagnosticTarget);
         if (!valid)
             reportCheckerDiagnostic(createDiagnostic({
                 code: "incompatible-indexer",
@@ -3092,7 +3095,7 @@ export function createChecker(program) {
         }
         switch (type.kind) {
             case "Scalar":
-                if (ignoreDiagnostics(isTypeAssignableTo(literalType, type, literalType))) {
+                if (ignoreDiagnostics(checker.isTypeAssignableTo(literalType, type, literalType))) {
                     return type;
                 }
                 return undefined;
@@ -3333,13 +3336,13 @@ export function createChecker(program) {
         if (target.kind === "ScalarConstructor") {
             return createScalarValue(node, mapper, target);
         }
-        if (areScalarsRelated(target, getStdType("string"))) {
+        if (relation.areScalarsRelated(target, getStdType("string"))) {
             return checkPrimitiveArg(node, target, "StringValue");
         }
-        else if (areScalarsRelated(target, getStdType("numeric"))) {
+        else if (relation.areScalarsRelated(target, getStdType("numeric"))) {
             return checkPrimitiveArg(node, target, "NumericValue");
         }
-        else if (areScalarsRelated(target, getStdType("boolean"))) {
+        else if (relation.areScalarsRelated(target, getStdType("boolean"))) {
             return checkPrimitiveArg(node, target, "BooleanValue");
         }
         else {
@@ -3419,7 +3422,7 @@ export function createChecker(program) {
         }
         const overriddenProp = getOverriddenProperty(newProp);
         if (overriddenProp) {
-            const [isAssignable, _] = isTypeAssignableTo(newProp.type, overriddenProp.type, newProp);
+            const [isAssignable, _] = relation.isTypeAssignableTo(newProp.type, overriddenProp.type, newProp);
             const parentType = getTypeName(overriddenProp.type);
             const newPropType = getTypeName(newProp.type);
             let invalid = false;
@@ -3920,7 +3923,7 @@ export function createChecker(program) {
         if (defaultValue === null) {
             return null;
         }
-        const [related, diagnostics] = isValueOfType(defaultValue, type, defaultNode);
+        const [related, diagnostics] = relation.isValueOfType(defaultValue, type, defaultNode);
         if (!related) {
             reportCheckerDiagnostics(diagnostics);
             return null;
@@ -4003,7 +4006,7 @@ export function createChecker(program) {
     }
     /** Check the decorator target is valid */
     function checkDecoratorTarget(targetType, declaration, decoratorNode) {
-        const [targetValid] = isTypeAssignableTo(targetType, declaration.target.type, decoratorNode);
+        const [targetValid] = relation.isTypeAssignableTo(targetType, declaration.target.type, decoratorNode);
         if (!targetValid) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "decorator-wrong-target",
@@ -4164,7 +4167,7 @@ export function createChecker(program) {
         return value;
     }
     function checkArgumentAssignable(argumentType, parameterType, diagnosticTarget) {
-        const [valid] = isTypeAssignableTo(argumentType, parameterType, diagnosticTarget);
+        const [valid] = relation.isTypeAssignableTo(argumentType, parameterType, diagnosticTarget);
         if (!valid) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "invalid-argument",
@@ -5599,7 +5602,7 @@ export function createChecker(program) {
      * @param diagnosticTarget Target for the diagnostic, unless something better can be inferred.
      */
     function checkTypeOfValueMatchConstraint(source, constraint, diagnosticTarget) {
-        const [related, diagnostics] = isTypeAssignableTo(source, constraint.type, diagnosticTarget);
+        const [related, diagnostics] = relation.isTypeAssignableTo(source, constraint.type, diagnosticTarget);
         if (!related) {
             if (constraint.kind === "argument") {
                 reportCheckerDiagnostic(createDiagnostic({
@@ -5624,552 +5627,19 @@ export function createChecker(program) {
      * @param diagnosticTarget Target for the diagnostic, unless something better can be inferred.
      */
     function checkTypeAssignable(source, target, diagnosticTarget) {
-        const [related, diagnostics] = isTypeAssignableTo(source, target, diagnosticTarget);
+        const [related, diagnostics] = relation.isTypeAssignableTo(source, target, diagnosticTarget);
         if (!related) {
             reportCheckerDiagnostics(diagnostics);
         }
         return related;
     }
     function checkValueOfType(source, target, diagnosticTarget) {
-        const [related, diagnostics] = isValueOfType(source, target, diagnosticTarget);
+        const [related, diagnostics] = relation.isValueOfType(source, target, diagnosticTarget);
         if (!related) {
             reportCheckerDiagnostics(diagnostics);
         }
         return related;
     }
-    /**
-     * Check if the source type can be assigned to the target type.
-     * @param source Source type
-     * @param target Target type
-     * @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];
-    }
-    /**
-     * Check if the given Value type is of the given type.
-     * @param source Value
-     * @param target Target type
-     * @param diagnosticTarget Target for the diagnostic, unless something better can be inferred.
-     */
-    function isValueOfType(source, target, diagnosticTarget) {
-        const [related, diagnostics] = isValueOfTypeInternal(source, target, diagnosticTarget, new MultiKeyMap());
-        return [related === Related.true, diagnostics];
-    }
-    function isTypeAssignableToInternal(source, target, diagnosticTarget, relationCache) {
-        const cached = relationCache.get([source, target]);
-        if (cached !== undefined) {
-            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) {
-        // BACKCOMPAT: Allow certain type to be accepted as values
-        if ("kind" in source &&
-            "entityKind" in target &&
-            source.kind === "TemplateParameter" &&
-            source.constraint?.type &&
-            source.constraint.valueType === undefined &&
-            target.entityKind === "MixedParameterConstraint" &&
-            target.valueType) {
-            const [assignable] = isTypeAssignableToInternal(source.constraint.type, target.valueType, diagnosticTarget, relationCache);
-            if (assignable) {
-                const constraint = getEntityName(source.constraint);
-                reportDeprecated(program, `Template constrainted to '${constraint}' will not be assignable to '${getEntityName(target)}' in the future. Update the constraint to be 'valueof ${constraint}'`, diagnosticTarget);
-                return [Related.true, []];
-            }
-        }
-        if ("kind" in source && source.kind === "TemplateParameter") {
-            source = source.constraint ?? unknownType;
-        }
-        if (target.entityKind === "Indeterminate") {
-            target = target.type;
-        }
-        if (source === target)
-            return [Related.true, []];
-        if (isValue(target)) {
-            return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
-        }
-        if (source.entityKind === "Indeterminate") {
-            return isIndeterminateEntityAssignableTo(source, target, diagnosticTarget, relationCache);
-        }
-        if (target.entityKind === "MixedParameterConstraint") {
-            return isAssignableToMixedParameterConstraint(source, target, diagnosticTarget, relationCache);
-        }
-        if (isValue(source) || (source.entityKind === "MixedParameterConstraint" && source.valueType)) {
-            return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
-        }
-        if (source.entityKind === "MixedParameterConstraint") {
-            return isTypeAssignableToInternal(source.type, target, diagnosticTarget, relationCache);
-        }
-        const isSimpleTypeRelated = isSimpleTypeAssignableTo(source, target);
-        if (isSimpleTypeRelated === true) {
-            return [Related.true, []];
-        }
-        else if (isSimpleTypeRelated === false) {
-            return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
-        }
-        if (source.kind === "Union") {
-            for (const variant of source.variants.values()) {
-                const [variantAssignable] = isTypeAssignableToInternal(variant.type, target, diagnosticTarget, relationCache);
-                if (!variantAssignable) {
-                    return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
-                }
-            }
-            return [Related.true, []];
-        }
-        if (target.kind === "Model" &&
-            source.kind === "Model" &&
-            target.name !== "object" &&
-            target.indexer === undefined &&
-            source.indexer &&
-            source.indexer.key.name === "integer") {
-            return [
-                Related.false,
-                [
-                    createDiagnostic({
-                        code: "missing-index",
-                        format: {
-                            indexType: getTypeName(source.indexer.key),
-                            sourceType: getTypeName(target),
-                        },
-                        target: diagnosticTarget,
-                    }),
-                ],
-            ];
-        }
-        else if (target.kind === "Model" &&
-            isArrayModelType(program, target) &&
-            source.kind === "Model") {
-            if (isArrayModelType(program, source)) {
-                return hasIndexAndIsAssignableTo(source, target, diagnosticTarget, relationCache);
-            }
-            else {
-                // For other models just fallback to unassignable
-                return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
-            }
-        }
-        else if (target.kind === "Model" && source.kind === "Model") {
-            return isModelRelatedTo(source, target, diagnosticTarget, relationCache);
-        }
-        else if (target.kind === "Model" &&
-            isArrayModelType(program, target) &&
-            source.kind === "Tuple") {
-            return isTupleAssignableToArray(source, target, diagnosticTarget, relationCache);
-        }
-        else if (target.kind === "Tuple" && source.kind === "Tuple") {
-            return isTupleAssignableToTuple(source, target, diagnosticTarget, relationCache);
-        }
-        else if (target.kind === "Union") {
-            return isAssignableToUnion(source, target, diagnosticTarget, relationCache);
-        }
-        else if (target.kind === "Enum") {
-            return isAssignableToEnum(source, target, diagnosticTarget);
-        }
-        return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
-    }
-    function isIndeterminateEntityAssignableTo(indeterminate, target, diagnosticTarget, relationCache) {
-        const [typeRelated, typeDiagnostics] = isTypeAssignableToInternal(indeterminate.type, target, diagnosticTarget, relationCache);
-        if (typeRelated) {
-            return [Related.true, []];
-        }
-        if (target.entityKind === "MixedParameterConstraint" && target.valueType) {
-            const [valueRelated] = isTypeAssignableToInternal(indeterminate.type, target.valueType, diagnosticTarget, relationCache);
-            if (valueRelated) {
-                return [Related.true, []];
-            }
-        }
-        return [Related.false, typeDiagnostics];
-    }
-    function isAssignableToValueType(source, target, diagnosticTarget, relationCache) {
-        if (!isValue(source)) {
-            return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
-        }
-        return isValueOfTypeInternal(source, target, diagnosticTarget, relationCache);
-    }
-    function isAssignableToMixedParameterConstraint(source, target, diagnosticTarget, relationCache) {
-        if ("entityKind" in source && source.entityKind === "MixedParameterConstraint") {
-            if (source.type && target.type) {
-                const [variantAssignable, diagnostics] = isTypeAssignableToInternal(source.type, target.type, diagnosticTarget, relationCache);
-                if (variantAssignable === Related.false) {
-                    return [Related.false, diagnostics];
-                }
-                return [Related.true, []];
-            }
-            if (source.valueType && target.valueType) {
-                const [variantAssignable, diagnostics] = isTypeAssignableToInternal(source.valueType, target.valueType, diagnosticTarget, relationCache);
-                if (variantAssignable === Related.false) {
-                    return [Related.false, diagnostics];
-                }
-                return [Related.true, []];
-            }
-            return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
-        }
-        if (target.type) {
-            const [related] = isTypeAssignableToInternal(source, target.type, diagnosticTarget, relationCache);
-            if (related) {
-                return [Related.true, []];
-            }
-        }
-        if (target.valueType) {
-            const [related] = isAssignableToValueType(source, target.valueType, diagnosticTarget, relationCache);
-            if (related) {
-                return [Related.true, []];
-            }
-        }
-        return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
-    }
-    /** Check if the value is assignable to the given type. */
-    function isValueOfTypeInternal(source, target, diagnosticTarget, relationCache) {
-        return isTypeAssignableToInternal(source.type, target, diagnosticTarget, relationCache);
-    }
-    function isReflectionType(type) {
-        return (type.kind === "Model" &&
-            type.namespace?.name === "Reflection" &&
-            type.namespace?.namespace?.name === "TypeSpec");
-    }
-    function isRelatedToScalar(source, target) {
-        switch (source.kind) {
-            case "Number":
-                return isNumericLiteralRelatedTo(source, target);
-            case "String":
-            case "StringTemplate":
-                return isStringLiteralRelatedTo(source, target);
-            case "Boolean":
-                return areScalarsRelated(target, getStdType("boolean"));
-            case "Scalar":
-                return areScalarsRelated(source, target);
-            case "Union":
-                return undefined;
-            default:
-                return false;
-        }
-    }
-    function areScalarsRelated(source, target) {
-        let current = source;
-        while (current) {
-            if (current === target) {
-                return true;
-            }
-            current = current.baseScalar;
-        }
-        return false;
-    }
-    function isSimpleTypeAssignableTo(source, target) {
-        if (isNeverType(source))
-            return true;
-        if (isVoidType(target))
-            return false;
-        if (isUnknownType(target))
-            return true;
-        if (isReflectionType(target)) {
-            return source.kind === ReflectionNameToKind[target.name];
-        }
-        if (target.kind === "Scalar") {
-            return isRelatedToScalar(source, target);
-        }
-        if (source.kind === "Scalar" && target.kind === "Model") {
-            return false;
-        }
-        if (target.kind === "String") {
-            return ((source.kind === "String" && source.value === target.value) ||
-                (source.kind === "StringTemplate" && source.stringValue === target.value));
-        }
-        if (target.kind === "StringTemplate" && target.stringValue) {
-            return ((source.kind === "String" && source.value === target.stringValue) ||
-                (source.kind === "StringTemplate" && source.stringValue === target.stringValue));
-        }
-        if (target.kind === "Number") {
-            return source.kind === "Number" && target.value === source.value;
-        }
-        return undefined;
-    }
-    function isNumericLiteralRelatedTo(source, target) {
-        // First check that the source numeric literal is assignable to the target scalar
-        if (!isNumericAssignableToNumericScalar(source.numericValue, target)) {
-            return false;
-        }
-        const min = getMinValueAsNumeric(program, target);
-        const max = getMaxValueAsNumeric(program, target);
-        const minExclusive = getMinValueExclusiveAsNumeric(program, target);
-        const maxExclusive = getMaxValueExclusiveAsNumeric(program, target);
-        if (min && source.numericValue.lt(min)) {
-            return false;
-        }
-        if (minExclusive && source.numericValue.lte(minExclusive)) {
-            return false;
-        }
-        if (max && source.numericValue.gt(max)) {
-            return false;
-        }
-        if (maxExclusive && source.numericValue.gte(maxExclusive)) {
-            return false;
-        }
-        return true;
-    }
-    function isNumericAssignableToNumericScalar(source, target) {
-        // if the target does not derive from numeric, then it can't be assigned a numeric literal
-        if (!areScalarsRelated(target.projectionBase ?? target, getStdType("numeric"))) {
-            return false;
-        }
-        // With respect to literal assignability a custom numeric scalar is
-        // equivalent to its nearest TypeSpec.* base. Adjust target accordingly.
-        while (!target.namespace || !isTypeSpecNamespace(target.namespace)) {
-            compilerAssert(target.baseScalar, "Should not be possible to be derived from TypeSpec.numeric and not have a base when not in TypeSpec namespace.");
-            target = target.baseScalar;
-        }
-        if (target.name === "numeric")
-            return true;
-        if (target.name === "decimal")
-            return true;
-        if (target.name === "decimal128")
-            return true;
-        const isInt = source.isInteger;
-        if (target.name === "integer")
-            return isInt;
-        if (target.name === "float")
-            return true;
-        if (!(target.name in numericRanges))
-            return false;
-        const [low, high, options] = numericRanges[target.name];
-        return source.gte(low) && source.lte(high) && (!options.int || isInt);
-    }
-    function isStringLiteralRelatedTo(source, target) {
-        if (!areScalarsRelated(target.projectionBase ?? target, getStdType("string"))) {
-            return false;
-        }
-        if (source.kind === "StringTemplate") {
-            return true;
-        }
-        const len = source.value.length;
-        const min = getMinLength(program, target);
-        const max = getMaxLength(program, target);
-        if (min && len < min) {
-            return false;
-        }
-        if (max && len > max) {
-            return false;
-        }
-        return true;
-    }
-    function isModelRelatedTo(source, target, diagnosticTarget, relationCache) {
-        relationCache.set([source, target], Related.maybe);
-        const diagnostics = [];
-        const remainingProperties = new Map(source.properties);
-        for (const prop of walkPropertiesInherited(target)) {
-            const sourceProperty = getProperty(source, prop.name);
-            if (sourceProperty === undefined) {
-                if (!prop.optional) {
-                    diagnostics.push(createDiagnostic({
-                        code: "missing-property",
-                        format: {
-                            propertyName: prop.name,
-                            sourceType: getTypeName(source),
-                            targetType: getTypeName(target),
-                        },
-                        target: source,
-                    }));
-                }
-            }
-            else {
-                remainingProperties.delete(prop.name);
-                if (sourceProperty.optional && !prop.optional) {
-                    diagnostics.push(createDiagnostic({
-                        code: "property-required",
-                        format: {
-                            propName: prop.name,
-                            targetType: getTypeName(target),
-                        },
-                        target: diagnosticTarget,
-                    }));
-                }
-                const [related, propDiagnostics] = isTypeAssignableToInternal(sourceProperty.type, prop.type, diagnosticTarget, relationCache);
-                if (!related) {
-                    diagnostics.push(...propDiagnostics);
-                }
-            }
-        }
-        if (target.indexer) {
-            const [_, indexerDiagnostics] = arePropertiesAssignableToIndexer(remainingProperties, target.indexer.value, diagnosticTarget, relationCache);
-            diagnostics.push(...indexerDiagnostics);
-            // For anonymous models we don't need an indexer
-            if (source.name !== "" && target.indexer.key.name !== "integer") {
-                const [related, indexDiagnostics] = hasIndexAndIsAssignableTo(source, target, diagnosticTarget, relationCache);
-                if (!related) {
-                    diagnostics.push(...indexDiagnostics);
-                }
-            }
-        }
-        else if (shouldCheckExcessProperties(source)) {
-            for (const [propName, prop] of remainingProperties) {
-                if (shouldCheckExcessProperty(prop)) {
-                    diagnostics.push(createDiagnostic({
-                        code: "unexpected-property",
-                        format: {
-                            propertyName: propName,
-                            type: getEntityName(target),
-                        },
-                        target: prop,
-                    }));
-                }
-            }
-        }
-        return [diagnostics.length === 0 ? Related.true : Related.false, diagnostics];
-    }
-    /** If we should check for excess properties on the given model. */
-    function shouldCheckExcessProperties(model) {
-        return model.node?.kind === SyntaxKind.ObjectLiteral;
-    }
-    /** If we should check for this specific property */
-    function shouldCheckExcessProperty(prop) {
-        return (prop.node?.kind === SyntaxKind.ObjectLiteralProperty && prop.node.parent === prop.model?.node);
-    }
-    function getProperty(model, name) {
-        return (model.properties.get(name) ??
-            (model.baseModel !== undefined ? getProperty(model.baseModel, name) : undefined));
-    }
-    function arePropertiesAssignableToIndexer(properties, indexerConstaint, diagnosticTarget, relationCache) {
-        for (const prop of properties.values()) {
-            const [related, diagnostics] = isTypeAssignableToInternal(prop.type, indexerConstaint, diagnosticTarget, relationCache);
-            if (!related) {
-                return [Related.false, diagnostics];
-            }
-        }
-        return [Related.true, []];
-    }
-    /** Check that the source model has an index, the index key match and the value of the source index is assignable to the target index. */
-    function hasIndexAndIsAssignableTo(source, target, diagnosticTarget, relationCache) {
-        if (source.indexer === undefined || source.indexer.key !== target.indexer.key) {
-            return [
-                Related.false,
-                [
-                    createDiagnostic({
-                        code: "missing-index",
-                        format: {
-                            indexType: getTypeName(target.indexer.key),
-                            sourceType: getTypeName(source),
-                        },
-                        target: diagnosticTarget,
-                    }),
-                ],
-            ];
-        }
-        return isTypeAssignableToInternal(source.indexer.value, target.indexer.value, diagnosticTarget, relationCache);
-    }
-    function isTupleAssignableToArray(source, target, diagnosticTarget, relationCache) {
-        const minItems = getMinItems(program, target);
-        const maxItems = getMaxItems(program, target);
-        if (minItems !== undefined && source.values.length < minItems) {
-            return [
-                Related.false,
-                [
-                    createDiagnostic({
-                        code: "unassignable",
-                        messageId: "withDetails",
-                        format: {
-                            sourceType: getEntityName(source),
-                            targetType: getTypeName(target),
-                            details: `Source has ${source.values.length} element(s) but target requires ${minItems}.`,
-                        },
-                        target: diagnosticTarget,
-                    }),
-                ],
-            ];
-        }
-        if (maxItems !== undefined && source.values.length > maxItems) {
-            return [
-                Related.false,
-                [
-                    createDiagnostic({
-                        code: "unassignable",
-                        messageId: "withDetails",
-                        format: {
-                            sourceType: getEntityName(source),
-                            targetType: getTypeName(target),
-                            details: `Source has ${source.values.length} element(s) but target only allows ${maxItems}.`,
-                        },
-                        target: diagnosticTarget,
-                    }),
-                ],
-            ];
-        }
-        for (const item of source.values) {
-            const [related, diagnostics] = isTypeAssignableToInternal(item, target.indexer.value, diagnosticTarget, relationCache);
-            if (!related) {
-                return [Related.false, diagnostics];
-            }
-        }
-        return [Related.true, []];
-    }
-    function isTupleAssignableToTuple(source, target, diagnosticTarget, relationCache) {
-        if (source.values.length !== target.values.length) {
-            return [
-                Related.false,
-                [
-                    createDiagnostic({
-                        code: "unassignable",
-                        messageId: "withDetails",
-                        format: {
-                            sourceType: getEntityName(source),
-                            targetType: getTypeName(target),
-                            details: `Source has ${source.values.length} element(s) but target requires ${target.values.length}.`,
-                        },
-                        target: diagnosticTarget,
-                    }),
-                ],
-            ];
-        }
-        for (const [index, sourceItem] of source.values.entries()) {
-            const targetItem = target.values[index];
-            const [related, diagnostics] = isTypeAssignableToInternal(sourceItem, targetItem, diagnosticTarget, relationCache);
-            if (!related) {
-                return [Related.false, diagnostics];
-            }
-        }
-        return [Related.true, []];
-    }
-    function isAssignableToUnion(source, target, diagnosticTarget, relationCache) {
-        if (source.kind === "UnionVariant" && source.union === target) {
-            return [Related.true, []];
-        }
-        for (const option of target.variants.values()) {
-            const [related] = isTypeAssignableToInternal(source, option.type, diagnosticTarget, relationCache);
-            if (related) {
-                return [Related.true, []];
-            }
-        }
-        return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
-    }
-    function isAssignableToEnum(source, target, diagnosticTarget) {
-        switch (source.kind) {
-            case "Enum":
-                if (source === target) {
-                    return [Related.true, []];
-                }
-                else {
-                    return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
-                }
-            case "EnumMember":
-                if (source.enum === target) {
-                    return [Related.true, []];
-                }
-                else {
-                    return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
-                }
-            default:
-                return [Related.false, [createUnassignableDiagnostic(source, target, diagnosticTarget)]];
-        }
-    }
-    function createUnassignableDiagnostic(source, target, diagnosticTarget) {
-        return createDiagnostic({
-            code: "unassignable",
-            format: { targetType: getEntityName(target), value: getEntityName(source) },
-            target: diagnosticTarget,
-        });
-    }
     function isStdType(type, stdType) {
         type = type.projectionBase ?? type;
         if ((type.kind !== "Model" && type.kind !== "Scalar") ||
@@ -6565,24 +6035,6 @@ function createDecoratorContext(program, decApp) {
 function isTemplatedNode(node) {
     return "templateParameters" in node && node.templateParameters.length > 0;
 }
-/**
- * Mapping from the reflection models to Type["kind"] value
- */
-const ReflectionNameToKind = {
-    Enum: "Enum",
-    EnumMember: "EnumMember",
-    Interface: "Interface",
-    Model: "Model",
-    ModelProperty: "ModelProperty",
-    Namespace: "Namespace",
-    Operation: "Operation",
-    Scalar: "Scalar",
-    TemplateParameter: "TemplateParameter",
-    Tuple: "Tuple",
-    Union: "Union",
-    UnionVariant: "UnionVariant",
-};
-const _assertReflectionNameToKind = ReflectionNameToKind;
 var ResolutionKind;
 (function (ResolutionKind) {
     ResolutionKind[ResolutionKind["Value"] = 0] = "Value";
@@ -6614,12 +6066,6 @@ class PendingResolutions {
         }
     }
 }
-var Related;
-(function (Related) {
-    Related[Related["false"] = 0] = "false";
-    Related[Related["true"] = 1] = "true";
-    Related[Related["maybe"] = 2] = "maybe";
-})(Related || (Related = {}));
 const defaultSymbolResolutionOptions = {
     resolveDecorators: false,
     checkTemplateTypes: true,