feat(compiler): Bring back the Map<K, V> type

.chronus/changes/feat-bring-back-map-type-2025-0-12-21-27-56.md

@@ -0,0 +1,7 @@
+---
+changeKind: feature
+packages:
+  - "@typespec/compiler"
+---
+
+Bring back the `Map<K, V>` type to intrinsics

packages/compiler/lib/intrinsics.tsp

@@ -184,8 +184,16 @@ scalar boolean;
 model Array<Element> {}
 
 /**
- * @dev Model with string properties where all the properties have type `Property`
+ * @dev Model with string properties where all the properties have type `Element`
  * @template Element The type of the properties
  */
 @indexer(string, Element)
 model Record<Element> {}
+
+/**
+ * @dev Model with string properties where all the keys have type `Key` and all the properties have type `Element`
+ * @template Key     The type of the keys
+ * @template Element The type of the properties
+ */
+@indexer(Key, Element)
+model Map<Key extends string, Element>  {}

packages/compiler/src/core/types.ts

@@ -280,7 +280,7 @@ export type NeverIndexer = {
 };
 
 export type ModelIndexer = {
-  readonly key: Scalar;
+  readonly key: Enum | Scalar | Union;
   readonly value: Type;
 };
 

packages/compiler/src/lib/intrinsic/decorators.ts

@@ -1,12 +1,19 @@
 import { DocTarget, setDocData } from "../../core/intrinsic-type-state.js";
 import type { Program } from "../../core/program.js";
-import type { DecoratorContext, ModelIndexer, Scalar, Type } from "../../core/types.js";
+import type {
+  DecoratorContext,
+  Enum,
+  ModelIndexer,
+  Scalar,
+  Type,
+  Union,
+} from "../../core/types.js";
 
 const indexTypeKey = Symbol.for(`TypeSpec.index`);
 export const indexerDecorator = (
   context: DecoratorContext,
   target: Type,
-  key: Scalar,
+  key: Enum | Scalar | Union,
   value: Type,
 ) => {
   const indexer: ModelIndexer = { key, value };

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

@@ -1183,6 +1183,63 @@ describe("compiler: models", () => {
       strictEqual(options[1].name, "string");
     });
 
+    it("can spread a Map<K, V>", async () => {
+      testHost.addTypeSpecFile("main.tsp", `@test model Test {...Map<string, int32>;}`);
+      const { Test } = (await testHost.compile("main.tsp")) as {
+        Test: Model;
+      };
+      ok(isRecordModelType(testHost.program, Test));
+      strictEqual(Test.indexer?.key.name, "string");
+      strictEqual(Test.indexer?.value.kind, "Scalar");
+      strictEqual(Test.indexer?.value.name, "int32");
+    });
+
+    it("can spread a Map<K, V> with different value than existing props", async () => {
+      testHost.addTypeSpecFile(
+        "main.tsp",
+        `
+        @test model Test {
+          name: string;
+          ...Map<string, int32>;
+        }
+        `,
+      );
+      const { Test } = (await testHost.compile("main.tsp")) as {
+        Test: Model;
+      };
+      ok(isRecordModelType(testHost.program, Test));
+      const nameProp = Test.properties.get("name");
+      strictEqual(nameProp?.type.kind, "Scalar");
+      strictEqual(nameProp?.type.name, "string");
+      strictEqual(Test.indexer?.key.name, "string");
+      strictEqual(Test.indexer?.value.kind, "Scalar");
+      strictEqual(Test.indexer?.value.name, "int32");
+    });
+
+    it("can spread different maps", async () => {
+      testHost.addTypeSpecFile(
+        "main.tsp",
+        `
+        @test model Test {
+          ...Map<string, int32>;
+          ...Map<string, string>;
+        }
+        `,
+      );
+      const { Test } = (await testHost.compile("main.tsp")) as {
+        Test: Model;
+      };
+      ok(isRecordModelType(testHost.program, Test));
+      strictEqual(Test.indexer?.key.name, "string");
+      const indexerValue = Test.indexer?.value;
+      strictEqual(indexerValue.kind, "Union");
+      const options = [...indexerValue.variants.values()].map((x) => x.type);
+      strictEqual(options[0].kind, "Scalar");
+      strictEqual(options[0].name, "int32");
+      strictEqual(options[1].kind, "Scalar");
+      strictEqual(options[1].name, "string");
+    });
+
     it("emit diagnostic if spreading an T[]", async () => {
       testHost.addTypeSpecFile(
         "main.tsp",

packages/compiler/test/checker/relation.test.ts

@@ -254,6 +254,7 @@ describe("compiler: checker: type relations", () => {
       "numeric",
       "float",
       "Record<string>",
+      "Map<string, string>",
       "bytes",
       "duration",
       "plainDate",
@@ -290,6 +291,7 @@ describe("compiler: checker: type relations", () => {
       "numeric",
       "float",
       "Record<string>",
+      "Map<string, string>",
       "bytes",
       "duration",
       "plainDate",
@@ -859,6 +861,97 @@ describe("compiler: checker: type relations", () => {
     });
   });
 
+  describe("Map<x, y> target", () => {
+    ["Map<string, integer>"].forEach((x) => {
+      it(`can assign ${x}`, async () => {
+        await expectTypeAssignable({ source: x, target: "Map<string, integer>" });
+      });
+    });
+
+    it("can assign empty object", async () => {
+      await expectTypeAssignable({ source: "{}", target: "Map<string, string>" });
+    });
+
+    it("can assign object with property being the same type", async () => {
+      await expectTypeAssignable({ source: "{foo: string}", target: "Map<string, string>" });
+      await expectTypeAssignable({
+        source: "{foo: string, bar: string}",
+        target: "Map<string, string>",
+      });
+    });
+
+    it("can assign object with property being the of subtype type", async () => {
+      await expectTypeAssignable({ source: "{foo: int32}", target: "Map<string, numeric>" });
+      await expectTypeAssignable({
+        source: "{foo: float, bar: int64}",
+        target: "Map<string, numeric>",
+      });
+    });
+
+    it("can assign a map of subtypes", async () => {
+      await expectTypeAssignable({ source: "Map<string, int32>", target: "Map<string, numeric>" });
+    });
+
+    it("can assign object that implement the same indexer", async () => {
+      await expectTypeAssignable({
+        source: "Foo",
+        target: "Map<string, string>",
+        commonCode: `
+        model Foo is Map<string, string> {
+          prop1: string;
+          prop2: string;
+        }
+      `,
+      });
+    });
+
+    it("type with spread indexer allow other properties to no match index", async () => {
+      await expectTypeAssignable({
+        source: "{age: int32, other: string}",
+        target: "Foo",
+        commonCode: `
+        model Foo {
+          age: int32;
+          ...Map<string, string>;
+        }
+      `,
+      });
+    });
+
+    it("emit diagnostic assigning other type", async () => {
+      await expectTypeNotAssignable(
+        { source: `string`, target: "Map<string, string>" },
+        {
+          code: "unassignable",
+          message: "Type 'string' is not assignable to type 'Map<string, string>'",
+        },
+      );
+    });
+
+    it("emit diagnostic assigning Map of incompatible type", async () => {
+      await expectTypeNotAssignable(
+        { source: `Map<string, int32>`, target: "Map<string, string>" },
+        {
+          code: "unassignable",
+          message: [
+            `Type 'Map<string, int32>' is not assignable to type 'Map<string, string>'`,
+            "  Type 'int32' is not assignable to type 'string'",
+          ].join("\n"),
+        },
+      );
+    });
+
+    it("emit diagnostic if some properties are different type", async () => {
+      await expectTypeNotAssignable(
+        { source: `{foo: string, bar: int32}`, target: "Map<string, string>" },
+        {
+          code: "unassignable",
+          message: "Type 'int32' is not assignable to type 'string'",
+        },
+      );
+    });
+  });
+
   describe("models", () => {
     it("can assign empty object", async () => {
       await expectTypeAssignable({ source: "{}", target: "{}" });

packages/compiler/test/stdlib.test.ts

@@ -20,6 +20,7 @@ const intrinsicTypes = [
   "decimal",
   "Array<string>",
   "Record<string>",
+  "Map<string, integer>",
   "string[]",
 ];