[compiler] Add typekit support to check if a type is in a namespace (microsoft#7090)

This pull request introduces a new feature to the `@typespec/compiler`
package, adding support for checking namespace membership using a new
`inNamespace` method. The changes include updates to the core type
system, implementation of the feature, and extensive test coverage to
ensure correctness.


Added a new `inNamespace` method to the `Type` TypeKit to determine if a
type belongs to a specific namespace. This method handles various type
scenarios, including models, enums, unions, and operations.
(`packages/compiler/src/experimental/typekit/kits/type.ts`,
[[1]](diffhunk://#diff-aaa7a0cba000f6acff7c2734746e5f87fcfd7676ee6ff0b49bbe11385194f854R124-R125)
[[2]](diffhunk://#diff-aaa7a0cba000f6acff7c2734746e5f87fcfd7676ee6ff0b49bbe11385194f854R277-R313)


Resolves microsoft#7036

Author: maorleger

.chronus/changes/type-in-namespace-2025-3-23-17-11-6.md

@@ -0,0 +1,7 @@
+---
+changeKind: feature
+packages:
+  - "@typespec/compiler"
+---
+
+Adds TypeKit support for type.inNamespace to check namespace membership

packages/compiler/src/experimental/typekit/kits/type.ts

@@ -14,7 +14,7 @@ import {
   getMinValueExclusive,
 } from "../../../core/intrinsic-type-state.js";
 import { isNeverType } from "../../../core/type-utils.js";
-import { Enum, Model, Scalar, Union, type Type } from "../../../core/types.js";
+import { Enum, Model, Namespace, Scalar, Union, type Type } from "../../../core/types.js";
 import { getDoc, getSummary, isErrorModel } from "../../../lib/decorators.js";
 import { resolveEncodedName } from "../../../lib/encoded-names.js";
 import { defineKit } from "../define-kit.js";
@@ -121,6 +121,15 @@ export interface TypeTypekit {
    * @returns True if the type is a user defined type, false otherwise.
    */
   isUserDefined(type: Type): boolean;
+
+  /**
+   * Checks if the given type is in the given namespace (directly or indirectly) by walking up the type's namespace chain.
+   *
+   * @param type The type to check.
+   * @param namespace The namespace to check membership against.
+   * @returns True if the type is in the namespace, false otherwise.
+   */
+  inNamespace(type: Type, namespace: Namespace): boolean;
 }
 
 interface TypekitExtension {
@@ -272,5 +281,37 @@ defineKit<TypekitExtension>({
     isUserDefined(type) {
       return getLocationContext(this.program, type).type === "project";
     },
+    inNamespace(type: Type, namespace: Namespace): boolean {
+      // A namespace is always in itself
+      if (type === namespace) {
+        return true;
+      }
+
+      // Handle types with known containers
+      switch (type.kind) {
+        case "ModelProperty":
+          if (type.model) {
+            return this.type.inNamespace(type.model, namespace);
+          }
+          break;
+        case "EnumMember":
+          return this.type.inNamespace(type.enum, namespace);
+        case "UnionVariant":
+          return this.type.inNamespace(type.union, namespace);
+        case "Operation":
+          if (type.interface) {
+            return this.type.inNamespace(type.interface, namespace);
+          }
+          // Operations that belong to a namespace directly will be handled in the generic case
+          break;
+      }
+
+      // Generic case handles all other types
+      if ("namespace" in type && type.namespace) {
+        return this.type.inNamespace(type.namespace, namespace);
+      }
+      // If we got this far, the type does not belong to the namespace
+      return false;
+    },
   },
 });

packages/compiler/test/experimental/typekit/type.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { Enum, Model, Scalar, Union } from "../../../src/core/types.js";
+import { Enum, Model, Namespace, Scalar, Union } from "../../../src/core/types.js";
 import { $ } from "../../../src/experimental/typekit/index.js";
 import { isTemplateInstance } from "../../../src/index.js";
 import { getTypes } from "./utils.js";
@@ -281,3 +281,195 @@ it("isError can check if a type is an error model", async () => {
   expect($(program).type.isError(Error)).toBe(true);
   expect($(program).type.isError(Foo)).toBe(false);
 });
+
+describe("inNamespace", () => {
+  it("checks that a namespace belongs to itself", async () => {
+    const {
+      Root,
+      context: { program },
+    } = await getTypes(
+      `
+      namespace Root {}
+      `,
+      ["Root"],
+    );
+    expect($(program).type.inNamespace(Root, Root as Namespace)).toBe(true);
+  });
+
+  it("checks direct namespace membership", async () => {
+    const {
+      Root,
+      context: { program },
+    } = await getTypes(
+      `
+      namespace Root {
+        namespace Child1 {
+          namespace Child2 {}
+        }
+      }
+      `,
+      ["Root"],
+    );
+
+    const child1 = (Root as Namespace).namespaces.get("Child1");
+    expect(child1).toBeDefined();
+    const child2 = child1?.namespaces.get("Child2");
+    expect(child2).toBeDefined();
+
+    expect($(program).type.inNamespace(child1!, Root as Namespace)).toBe(true);
+    expect($(program).type.inNamespace(child2!, Root as Namespace)).toBe(true);
+  });
+
+  it("checks model property namespace membership", async () => {
+    const {
+      Root,
+      Outside,
+      context: { program },
+    } = await getTypes(
+      `
+      namespace Root {
+        model Inside {
+          prop: string;
+        }
+      }
+
+      model Outside {
+        prop: string;
+      }
+      `,
+      ["Root", "Inside", "Outside"],
+    );
+
+    const model1 = (Root as Namespace).models.get("Inside");
+    expect(model1).toBeDefined();
+    const prop1 = model1?.properties.get("prop");
+    expect(prop1).toBeDefined();
+
+    const prop2 = (Outside as Model).properties.get("prop");
+    expect(prop2).toBeDefined();
+
+    expect($(program).type.inNamespace(prop1!, Root as Namespace)).toBe(true);
+    expect($(program).type.inNamespace(prop2!, Root as Namespace)).toBe(false);
+  });
+
+  it("checks enum member namespace membership", async () => {
+    const {
+      Root,
+      context: { program },
+    } = await getTypes(
+      `
+      namespace Root {
+        enum Test {
+          A,
+          B
+        }
+      }
+      `,
+      ["Root"],
+    );
+
+    const enum1 = (Root as Namespace).enums.get("Test");
+    const enumMember = enum1?.members.get("A");
+    expect(enumMember).toBeDefined();
+
+    expect($(program).type.inNamespace(enumMember!, Root as Namespace)).toBe(true);
+  });
+
+  it("checks union variant namespace membership", async () => {
+    const {
+      Root,
+      context: { program },
+    } = await getTypes(
+      `
+      namespace Root {
+        union Test {
+          A: string,
+          B: int32
+        }
+      }
+      `,
+      ["Root"],
+    );
+
+    const union = (Root as Namespace).unions.get("Test");
+    const variant = union?.variants.get("A");
+    expect(variant).toBeDefined();
+
+    expect($(program).type.inNamespace(variant!, Root as Namespace)).toBe(true);
+  });
+
+  it("checks interface operation namespace membership", async () => {
+    const {
+      Root,
+      context: { program },
+    } = await getTypes(
+      `
+      namespace Root {
+        interface Test {
+          op myOp(): void;
+        }
+      }
+      `,
+      ["Root"],
+    );
+
+    const test = (Root as Namespace).interfaces.get("Test");
+    const operation = test?.operations.get("myOp");
+    expect(operation).toBeDefined();
+
+    expect($(program).type.inNamespace(operation!, Root as Namespace)).toBe(true);
+  });
+
+  it("checks operations namespace membership", async () => {
+    const {
+      Root,
+      context: { program },
+    } = await getTypes(
+      `
+      namespace Root {
+        op myOp(): void;
+      }
+      `,
+      ["Root"],
+    );
+    const operation = (Root as Namespace).operations.get("myOp");
+    expect(operation).toBeDefined();
+
+    expect($(program).type.inNamespace(operation!, Root as Namespace)).toBe(true);
+  });
+
+  it("returns false for types outside the namespace", async () => {
+    const {
+      Root,
+      Outside,
+      context: { program },
+    } = await getTypes(
+      `
+      namespace Root {
+        namespace Child1 {}
+      }
+      namespace Outside {}
+      `,
+      ["Root", "Outside"],
+    );
+    const child1 = (Root as Namespace).namespaces.get("Child1");
+    expect(child1).toBeDefined();
+
+    expect($(program).type.inNamespace(child1!, Outside as Namespace)).toBe(false);
+  });
+
+  it("returns false for types without namespace", async () => {
+    const {
+      MyNamespace,
+      context: { program },
+    } = await getTypes(
+      `
+      namespace MyNamespace { }
+      `,
+      ["MyNamespace"],
+    );
+
+    const stringLiteral = $(program).literal.create("test");
+    expect($(program).type.inNamespace(stringLiteral, MyNamespace as Namespace)).toBe(false);
+  });
+});