@typespec/compiler 0.48.0-dev.1 → 0.48.0-dev.12

package/dist/src/core/checker.js

@@ -342,6 +342,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 +988,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 +1011,7 @@ export function createChecker(program) {
                 kind: "Namespace",
                 name,
                 namespace,
-                node,
+                node: node,
                 models: new Map(),
                 scalars: new Map(),
                 operations: new Map(),
@@ -1074,7 +1077,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);
         }
@@ -1645,7 +1648,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) {
@@ -1830,11 +1833,23 @@ export function createChecker(program) {
         checkModelProperties(node, properties, type, mapper);
         return finishType(type);
     }
+    /** Find the indexer that applies to this model. Either defined on itself or from a base model */
+    function findIndexer(model) {
+        let current = model;
+        while (current) {
+            if (current.indexer) {
+                return current.indexer;
+            }
+            current = current.baseModel;
+        }
+        return undefined;
+    }
     function checkPropertyCompatibleWithIndexer(parentModel, property, diagnosticTarget) {
-        if (parentModel.indexer === undefined) {
+        const indexer = findIndexer(parentModel);
+        if (indexer === undefined) {
             return;
         }
-        const [valid, diagnostics] = isTypeAssignableTo(property.type, parentModel.indexer.value, diagnosticTarget.kind === SyntaxKind.ModelSpreadProperty
+        const [valid, diagnostics] = isTypeAssignableTo(property.type, indexer.value, diagnosticTarget.kind === SyntaxKind.ModelSpreadProperty
             ? diagnosticTarget
             : diagnosticTarget.value);
         if (!valid)
@@ -3782,42 +3797,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" &&
@@ -3826,7 +3854,7 @@ export function createChecker(program) {
             source.indexer &&
             source.indexer.key.name === "integer") {
             return [
-                false,
+                Related.false,
                 [
                     createDiagnostic({
                         code: "missing-index",
@@ -3840,43 +3868,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;
@@ -3959,7 +3987,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);
@@ -3977,27 +4006,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",
@@ -4010,7 +4039,7 @@ export function createChecker(program) {
                     ],
                 ];
             }
-            return isTypeAssignableTo(source.indexer.value, target.indexer.value, diagnosticTarget);
+            return isTypeAssignableToInternal(source.indexer.value, target.indexer.value, diagnosticTarget, relationCache);
         }
     }
     /**
@@ -4018,25 +4047,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",
@@ -4053,40 +4082,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) {
@@ -4507,4 +4536,10 @@ const ReflectionNameToKind = {
     UnionVariant: "UnionVariant",
 };
 const _assertReflectionNameToKind = ReflectionNameToKind;
+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