Remove unused program param from isArrayModelType and isRecordModelType

.chronus/changes/fionabronwen-type-utils-2026-0-12-16-12-5.md

@@ -0,0 +1,12 @@
+---
+changeKind: deprecation
+packages:
+  - "@typespec/compiler"
+  - "@typespec/http"
+  - "@typespec/openapi3"
+  - "@typespec/tspd"
+  - "@typespec/http-server-js"
+  - "@typespec/http-server-csharp"
+---
+
+Deprecate `program` parameter in `isArrayModelType` and `isRecordModelType` functions. Use the new single-argument overload instead: `isArrayModelType(type)` and `isRecordModelType(type)`.

packages/compiler/src/core/checker.ts

@@ -4730,7 +4730,7 @@ export function createChecker(program: Program, resolver: NameResolver): Checker
       );
       return [[], undefined];
     }
-    if (isArrayModelType(program, targetType)) {
+    if (isArrayModelType(targetType)) {
       reportCheckerDiagnostic(
         createDiagnostic({ code: "spread-model", target: targetNode }),
         mapper,
@@ -5096,17 +5096,14 @@ export function createChecker(program: Program, resolver: NameResolver): Checker
     let valueType: Type | undefined;
     let type: Type | undefined;
     if (constraint.valueType) {
-      if (
-        constraint.valueType.kind === "Model" &&
-        isArrayModelType(program, constraint.valueType)
-      ) {
+      if (constraint.valueType.kind === "Model" && isArrayModelType(constraint.valueType)) {
         valueType = constraint.valueType.indexer.value;
       } else {
         return undefined;
       }
     }
     if (constraint.type) {
-      if (constraint.type.kind === "Model" && isArrayModelType(program, constraint.type)) {
+      if (constraint.type.kind === "Model" && isArrayModelType(constraint.type)) {
         type = constraint.type.indexer.value;
       } else {
         return undefined;

packages/compiler/src/core/type-relation-checker.ts

@@ -321,12 +321,8 @@ export function createTypeRelationChecker(program: Program, checker: Checker): T
           }),
         ],
       ];
-    } else if (
-      target.kind === "Model" &&
-      isArrayModelType(program, target) &&
-      source.kind === "Model"
-    ) {
-      if (isArrayModelType(program, source)) {
+    } else if (target.kind === "Model" && isArrayModelType(target) && source.kind === "Model") {
+      if (isArrayModelType(source)) {
         return hasIndexAndIsAssignableTo(
           source,
           target as Model & { indexer: ModelIndexer },
@@ -339,11 +335,7 @@ export function createTypeRelationChecker(program: Program, checker: Checker): T
       }
     } else if (target.kind === "Model" && source.kind === "Model") {
       return areModelsRelated(source, target, diagnosticTarget, relationCache);
-    } else if (
-      target.kind === "Model" &&
-      isArrayModelType(program, target) &&
-      source.kind === "Tuple"
-    ) {
+    } else if (target.kind === "Model" && isArrayModelType(target) && source.kind === "Tuple") {
       return isTupleAssignableToArray(source, target, diagnosticTarget, relationCache);
     } else if (target.kind === "Tuple" && source.kind === "Tuple") {
       return isTupleAssignableToTuple(source, target, diagnosticTarget, relationCache);

packages/compiler/src/core/type-utils.ts

@@ -11,6 +11,7 @@ import {
   Node,
   NullType,
   Operation,
+  RecordModelType,
   Sym,
   SymbolFlags,
   SyntaxKind,
@@ -51,17 +52,36 @@ export function isValue(entity: Entity): entity is Value {
 }
 
 /**
+ * Check if a model is an array type.
+ * @param program Program (unused)
+ * @param type Model type
+ * @deprecated Use `isArrayModelType(type)` instead. The `program` parameter is unused.
+ */
+export function isArrayModelType(program: Program, type: Model): type is ArrayModelType;
+/**
+ * Check if a model is an array type.
  * @param type Model type
  */
-export function isArrayModelType(program: Program, type: Model): type is ArrayModelType {
+export function isArrayModelType(type: Model): type is ArrayModelType;
+export function isArrayModelType(programOrType: Program | Model, maybeType?: Model): boolean {
+  const type = maybeType ?? (programOrType as Model);
   return Boolean(type.indexer && type.indexer.key.name === "integer");
 }
 
 /**
- * Check if a model is an array type.
+ * Check if a model is a record type.
+ * @param program Program (unused)
+ * @param type Model type
+ * @deprecated Use `isRecordModelType(type)` instead. The `program` parameter is unused.
+ */
+export function isRecordModelType(program: Program, type: Model): type is RecordModelType;
+/**
+ * Check if a model is a record type.
  * @param type Model type
  */
-export function isRecordModelType(program: Program, type: Model): type is ArrayModelType {
+export function isRecordModelType(type: Model): type is RecordModelType;
+export function isRecordModelType(programOrType: Program | Model, maybeType?: Model): boolean {
+  const type = maybeType ?? (programOrType as Model);
   return Boolean(type.indexer && type.indexer.key.name === "string");
 }
 

packages/compiler/src/index.ts

@@ -284,6 +284,7 @@ export {
   type NavigationOptions,
 } from "./core/semantic-walker.js";
 export { createSourceFile, getSourceFileKindFromExt } from "./core/source-file.js";
+/* eslint-disable @typescript-eslint/no-deprecated -- exporting deprecated overloads for backward compatibility */
 export {
   isArrayModelType,
   isDeclaredInNamespace,
@@ -301,6 +302,7 @@ export {
   isValue,
   isVoidType,
 } from "./core/type-utils.js";
+/* eslint-enable @typescript-eslint/no-deprecated */
 export { ListenerFlow, NoTarget } from "./core/types.js";
 export type {
   ArrayModelType,

packages/compiler/src/lib/decorators.ts

@@ -390,10 +390,7 @@ function validateTargetingAnArray(
   decoratorName: string,
 ) {
   const targetType = getTypeForArrayValidation(target);
-  const valid = isTypeIn(
-    targetType,
-    (x) => x.kind === "Model" && isArrayModelType(context.program, x),
-  );
+  const valid = isTypeIn(targetType, (x) => x.kind === "Model" && isArrayModelType(x));
   if (!valid) {
     reportDiagnostic(context.program, {
       code: "decorator-wrong-target",

packages/compiler/src/lib/examples.ts

@@ -40,7 +40,7 @@ export function serializeValueAsJson(
         serializeValueAsJson(
           program,
           v,
-          type.kind === "Model" && isArrayModelType(program, type)
+          type.kind === "Model" && isArrayModelType(type)
             ? type.indexer.value
             : program.checker.anyType,
         ),

packages/compiler/src/lib/paging.ts

@@ -87,7 +87,7 @@ export const [
   /** {@inheritdoc PageItemsDecorator} */
   pageItemsDecorator,
 ] = createMarkerDecorator<PageItemsDecorator>("pageItems", (context, target) => {
-  if (target.type.kind !== "Model" || !isArrayModelType(context.program, target.type)) {
+  if (target.type.kind !== "Model" || !isArrayModelType(target.type)) {
     reportDiagnostic(context.program, {
       code: "decorator-wrong-target",
       messageId: "withExpected",

packages/compiler/src/typekit/kits/array.ts

@@ -35,7 +35,7 @@ defineKit<TypekitExtension>({
       return (
         type.entityKind === "Type" &&
         type.kind === "Model" &&
-        isArrayModelType(this.program, type) &&
+        isArrayModelType(type) &&
         type.properties.size === 0
       );
     },

packages/compiler/src/typekit/kits/record.ts

@@ -39,7 +39,7 @@ defineKit<TypekitExtension>({
       return (
         type.entityKind === "Type" &&
         type.kind === "Model" &&
-        isRecordModelType(this.program, type) &&
+        isRecordModelType(type) &&
         type.properties.size === 0
       );
     },

packages/compiler/test/checker/model.test.ts

@@ -847,7 +847,7 @@ describe("compiler: models", () => {
         `,
       );
       const { A } = (await testHost.compile("main.tsp")) as { A: Model };
-      ok(isArrayModelType(testHost.program, A));
+      ok(isArrayModelType(A));
     });
 
     it("model is accept array expression of complex type", async () => {
@@ -859,7 +859,7 @@ describe("compiler: models", () => {
         `,
       );
       const { A } = (await testHost.compile("main.tsp")) as { A: Model };
-      ok(isArrayModelType(testHost.program, A));
+      ok(isArrayModelType(A));
       strictEqual(A.indexer.value.kind, "Union");
     });
 
@@ -1124,7 +1124,7 @@ describe("compiler: models", () => {
       const { Test } = (await testHost.compile("main.tsp")) as {
         Test: Model;
       };
-      ok(isRecordModelType(testHost.program, Test));
+      ok(isRecordModelType(Test));
       strictEqual(Test.indexer?.key.name, "string");
       strictEqual(Test.indexer?.value.kind, "Scalar");
       strictEqual(Test.indexer?.value.name, "int32");
@@ -1143,7 +1143,7 @@ describe("compiler: models", () => {
       const { Test } = (await testHost.compile("main.tsp")) as {
         Test: Model;
       };
-      ok(isRecordModelType(testHost.program, Test));
+      ok(isRecordModelType(Test));
       const nameProp = Test.properties.get("name");
       strictEqual(nameProp?.type.kind, "Scalar");
       strictEqual(nameProp?.type.name, "string");
@@ -1165,7 +1165,7 @@ describe("compiler: models", () => {
       const { Test } = (await testHost.compile("main.tsp")) as {
         Test: Model;
       };
-      ok(isRecordModelType(testHost.program, Test));
+      ok(isRecordModelType(Test));
       strictEqual(Test.indexer?.key.name, "string");
       const indexerValue = Test.indexer?.value;
       strictEqual(indexerValue.kind, "Union");

packages/http-server-csharp/src/lib/attributes.ts

@@ -308,7 +308,7 @@ export function getArrayConstraintAttribute(
   const maxItems = getMaxItems(program, type);
   if (minItems === undefined && maxItems === undefined) return undefined;
   if (type.kind !== "ModelProperty" || type.type.kind !== "Model") return undefined;
-  if (!isArrayModelType(program, type.type)) return undefined;
+  if (!isArrayModelType(type.type)) return undefined;
   const arrayType = type.type;
   const elementType = arrayType.indexer.value;
   if (elementType.kind !== "Scalar") return undefined;

packages/http-server-csharp/src/lib/type-helpers.ts

@@ -70,11 +70,7 @@ export function getEnumType(en: Enum): EnumValueType | undefined {
  * @returns true if the type is an array or a model property with array type, otherwise false
  */
 export function isArrayType(program: Program, type: ModelProperty | Scalar): boolean {
-  return (
-    type.kind === "ModelProperty" &&
-    type.type.kind === "Model" &&
-    isArrayModelType(program, type.type)
-  );
+  return type.kind === "ModelProperty" && type.type.kind === "Model" && isArrayModelType(type.type);
 }
 
 /** Inner representation of s string constraint */

packages/http-server-csharp/src/lib/utils.ts

@@ -1586,7 +1586,7 @@ export class CSharpOperationHelpers {
             nullableType: false,
             hasUniqueItems: hasUniqueItems,
           };
-        } else if (isArrayModelType(program, tsType)) {
+        } else if (isArrayModelType(tsType)) {
           const typeReference = code`${this.emitter.emitTypeReference(tsType.indexer.value)}`;
           modelResult = isByteType(tsType.indexer.value)
             ? {

packages/http-server-js/src/common/reference.ts

@@ -73,7 +73,7 @@ export function emitTypeReference(
       return getJsScalar(ctx, module, type, position).type;
     case "Model": {
       // First handle arrays.
-      if (isArrayModelType(ctx.program, type)) {
+      if (isArrayModelType(type)) {
         const argumentType = type.indexer.value;
 
         const argTypeReference = emitTypeReference(ctx, argumentType, position, module, {

packages/http-server-js/src/common/serialization/json.ts

@@ -64,7 +64,7 @@ export function requiresJsonSerialization(
 
   switch (type.kind) {
     case "Model": {
-      if (isArrayModelType(ctx.program, type)) {
+      if (isArrayModelType(type)) {
         const argumentType = type.indexer.value;
         requiresSerialization = requiresJsonSerialization(ctx, module, argumentType);
         break;
@@ -237,15 +237,15 @@ export function transposeExpressionToJson(
 ): string {
   switch (type.kind) {
     case "Model": {
-      if (isArrayModelType(ctx.program, type)) {
+      if (isArrayModelType(type)) {
         const argumentType = type.indexer.value;
 
         if (requiresJsonSerialization(ctx, module, argumentType)) {
           return `(${expr})?.map((item) => ${transposeExpressionToJson(ctx, argumentType, "item", module)})`;
         } else {
           return expr;
         }
-      } else if (isRecordModelType(ctx.program, type)) {
+      } else if (isRecordModelType(type)) {
         const argumentType = type.indexer.value;
 
         if (requiresJsonSerialization(ctx, module, argumentType)) {
@@ -480,15 +480,15 @@ export function transposeExpressionFromJson(
 ): string {
   switch (type.kind) {
     case "Model": {
-      if (isArrayModelType(ctx.program, type)) {
+      if (isArrayModelType(type)) {
         const argumentType = type.indexer.value;
 
         if (requiresJsonSerialization(ctx, module, argumentType)) {
           return `(${expr})?.map((item: any) => ${transposeExpressionFromJson(ctx, argumentType, "item", module)})`;
         } else {
           return expr;
         }
-      } else if (isRecordModelType(ctx.program, type)) {
+      } else if (isRecordModelType(type)) {
         const argumentType = type.indexer.value;
 
         if (requiresJsonSerialization(ctx, module, argumentType)) {

packages/http-server-js/src/ctx.ts

@@ -47,9 +47,7 @@ export type DeclarationType = Model | Enum | Union | Interface | Scalar;
  */
 export function isImportableType(ctx: JsContext, t: Type): t is DeclarationType {
   return (
-    (t.kind === "Model" &&
-      !isArrayModelType(ctx.program, t) &&
-      !isRecordModelType(ctx.program, t)) ||
+    (t.kind === "Model" && !isArrayModelType(t) && !isRecordModelType(t)) ||
     t.kind === "Enum" ||
     t.kind === "Interface"
   );

packages/http-server-js/src/http/server/index.ts

@@ -250,7 +250,7 @@ function* emitRawServerOperation(
         let value: string;
 
         if (requiresJsonSerialization(ctx, module, body.type)) {
-          if (body.type.kind === "Model" && isArrayModelType(ctx.program, body.type)) {
+          if (body.type.kind === "Model" && isArrayModelType(body.type)) {
             yield `        const __arrayBody = JSON.parse(body);`;
             yield `        if (!Array.isArray(__arrayBody)) {`;
             yield `          ${names.ctx}.errorHandlers.onInvalidRequest(`;
@@ -261,7 +261,7 @@ function* emitRawServerOperation(
             yield `          return reject();`;
             yield `        }`;
             value = transposeExpressionFromJson(ctx, body.type, `__arrayBody`, module);
-          } else if (body.type.kind === "Model" && isRecordModelType(ctx.program, body.type)) {
+          } else if (body.type.kind === "Model" && isRecordModelType(body.type)) {
             yield `        const __recordBody = JSON.parse(body);`;
             yield `        if (typeof __recordBody !== "object" || __recordBody === null) {`;
             yield `          ${names.ctx}.errorHandlers.onInvalidRequest(`;
@@ -641,7 +641,7 @@ function* emitResultProcessingForType(
     } else {
       yield `${names.ctx}.response.end(globalThis.JSON.stringify(${names.result}.${bodyCase.camelCase}));`;
     }
-  } else if (isArrayModelType(ctx.program, target)) {
+  } else if (isArrayModelType(target)) {
     const itemType = target.indexer.value;
 
     const serializationRequired = isSerializationRequired(
@@ -659,7 +659,7 @@ function* emitResultProcessingForType(
     } else {
       yield `${names.ctx}.response.end(globalThis.JSON.stringify(${names.result}));`;
     }
-  } else if (isRecordModelType(ctx.program, target)) {
+  } else if (isRecordModelType(target)) {
     const itemType = target.indexer.value;
 
     const serializationRequired = isSerializationRequired(

packages/http-server-js/src/util/differentiate.ts

@@ -676,7 +676,7 @@ export function differentiateModelTypes(
   let arrayVariant: Model | undefined = undefined;
 
   for (const model of models) {
-    if (isArrayModelType(ctx.program, model) && model.properties.size === 0 && !arrayVariant) {
+    if (isArrayModelType(model) && model.properties.size === 0 && !arrayVariant) {
       arrayVariant = model;
       continue;
     }

packages/http/src/experimental/merge-patch/helpers.ts

@@ -56,7 +56,7 @@ export function getMergePatchProperties(
   function getUpdateBehavior(type: Type): "merge" | "replace" {
     switch (type.kind) {
       case "Model":
-        if (isArrayModelType(program, type)) return "merge";
+        if (isArrayModelType(type)) return "merge";
         return "replace";
       default:
         return "replace";

packages/http/src/payload.ts

@@ -133,7 +133,7 @@ function resolveBody(
   }
 
   // non-model or intrinsic/array model -> response body is response type
-  if (requestOrResponseType.kind !== "Model" || isArrayModelType(program, requestOrResponseType)) {
+  if (requestOrResponseType.kind !== "Model" || isArrayModelType(requestOrResponseType)) {
     return diagnostics.wrap({
       bodyKind: "single",
       ...diagnostics.pipe(
@@ -516,7 +516,7 @@ function resolvePartOrParts(
   visibility: Visibility,
   property?: ModelProperty,
 ): DiagnosticResult<HttpOperationPartCommon | undefined> {
-  if (type.kind === "Model" && isArrayModelType(program, type)) {
+  if (type.kind === "Model" && isArrayModelType(type)) {
     const [part, diagnostics] = resolvePart(program, type.indexer.value, visibility, property);
     if (part) {
       return [{ ...part, multi: true }, diagnostics];