@alloy-js/csharp 0.21.0-dev.1 → 0.21.0-dev.3

package/src/components/record/declaration.tsx

@@ -26,7 +26,7 @@ export interface RecordDeclarationProps
   extends Omit<core.DeclarationProps, "nameKind">,
     AccessModifiers,
     RecordModifiers {
-  name: string;
+  name: string | core.Namekey;
 
   /** Doc comment */
   doc?: core.Children;
@@ -73,12 +73,11 @@ export interface RecordDeclarationProps
  * ```
  */
 export function RecordDeclaration(props: RecordDeclarationProps) {
-  const name = useCSharpNamePolicy().getName(props.name!, "record");
-
   // records don't have their own type kind but instead use class or struct
   // depending on what kind of record we have.
-  const thisRecordSymbol = createNamedTypeSymbol(name, "record", {
+  const thisRecordSymbol = createNamedTypeSymbol(props.name, "record", {
     refkeys: props.refkey,
+    namePolicy: useCSharpNamePolicy().for("record"),
   });
 
   const thisRecordScope = createClassScope(thisRecordSymbol);

package/src/components/source-file/source-file.test.tsx

@@ -1,5 +1,5 @@
 import { ClassDeclaration } from "#components/class/declaration.jsx";
-import { Namespace } from "#components/namespace.jsx";
+import { Namespace } from "#components/namespace/namespace.jsx";
 import { Children, FormatOptions, Indent, Output, Prose } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import { CSharpFormatOptions } from "../../contexts/format-options.js";

package/src/components/source-file/source-file.tsx

@@ -1,4 +1,5 @@
 import { NamespaceScopes } from "#components/namespace-scopes.jsx";
+import { NamespaceName } from "#components/namespace/namespace-name.jsx";
 import { Reference } from "#components/Reference.jsx";
 import { Usings } from "#components/using/using.jsx";
 import {
@@ -42,7 +43,6 @@ export function SourceFile(props: SourceFileProps) {
   const nsContext = useNamespaceContext();
   const globalNs = getGlobalNamespace(useBinder());
   const nsSymbol = nsContext ? nsContext.symbol : globalNs;
-  const nsRef = nsContext ? nsContext.symbol.name : undefined;
   const usings = computed(() => {
     return (
       Array.from(sourceFileScope.usings) as (NamespaceSymbol | string)[]
@@ -78,7 +78,7 @@ export function SourceFile(props: SourceFileProps) {
         {nsSymbol === globalNs ?
           content
         : <>
-            namespace {nsRef}
+            namespace <NamespaceName symbol={nsSymbol} />
             {sourceFileScope.hasBlockNamespace ?
               <>
                 {" "}

package/src/components/source-file/using.test.tsx

@@ -2,7 +2,7 @@ import { ClassDeclaration } from "#components/class/declaration.jsx";
 import { EnumDeclaration } from "#components/enum/declaration.jsx";
 import { EnumMember } from "#components/enum/member.jsx";
 import { Method } from "#components/method/method.jsx";
-import { Namespace } from "#components/namespace.jsx";
+import { Namespace } from "#components/namespace/namespace.jsx";
 import { SourceFile } from "#components/source-file/source-file.jsx";
 import { Output, refkey } from "@alloy-js/core";
 import * as coretest from "@alloy-js/core/testing";

package/src/components/struct/declaration.test.tsx

@@ -1,4 +1,4 @@
-import { List, refkey } from "@alloy-js/core";
+import { List, namekey, refkey } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { Attribute } from "../attributes/attributes.jsx";
@@ -19,6 +19,16 @@ it("declares struct with no members", () => {
   `);
 });
 
+it("takes a namekey", () => {
+  expect(
+    <TestNamespace>
+      <StructDeclaration name={namekey("my-struct")} />
+    </TestNamespace>,
+  ).toRenderTo(`
+      struct MyStruct;
+  `);
+});
+
 describe("modifiers", () => {
   it.each(["public", "private", "internal"])("%s", (mod) => {
     expect(

package/src/components/struct/declaration.tsx

@@ -35,7 +35,7 @@ export interface StructDeclarationProps
   extends Omit<core.DeclarationProps, "nameKind">,
     AccessModifiers,
     StructModifiers {
-  name: string;
+  name: string | core.Namekey;
 
   /** Doc comment */
   doc?: core.Children;
@@ -98,10 +98,9 @@ export interface StructDeclarationProps
  * ```
  */
 export function StructDeclaration(props: StructDeclarationProps) {
-  const name = useCSharpNamePolicy().getName(props.name!, "struct");
-
-  const thisStructSymbol = createNamedTypeSymbol(name, "struct", {
+  const thisStructSymbol = createNamedTypeSymbol(props.name, "struct", {
     refkeys: props.refkey,
+    namePolicy: useCSharpNamePolicy().for("struct"),
   });
 
   const thisStructScope = createNamedTypeScope(thisStructSymbol);

package/src/components/type-parameters/type-parameter.tsx

@@ -2,6 +2,7 @@ import {
   Children,
   MemberDeclaration,
   MemberName,
+  Namekey,
   Refkey,
 } from "@alloy-js/core";
 import { createTypeParameterSymbol } from "../../symbols/factories.js";
@@ -13,7 +14,7 @@ export interface TypeParameterProps {
   /**
    * The name of the type parameter.
    */
-  readonly name: string;
+  readonly name: string | Namekey;
 
   /**
    * The parameter constraint

package/src/components/type-parameters/type-parameters.test.tsx

@@ -1,3 +1,4 @@
+import { namekey } from "@alloy-js/core";
 import { expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { TypeParameters } from "./type-parameters.jsx";
@@ -44,3 +45,11 @@ it("declare type parameters using parameters", () => {
     </TestNamespace>,
   ).toRenderTo(`<A, B>`);
 });
+
+it("takes a namekey", () => {
+  expect(
+    <TestNamespace>
+      <TypeParameters parameters={[{ name: namekey("my-param") }]} />
+    </TestNamespace>,
+  ).toRenderTo(`<MyParam>`);
+});

package/src/components/var/declaration.test.tsx

@@ -1,4 +1,4 @@
-import { List, refkey } from "@alloy-js/core";
+import { List, namekey, refkey } from "@alloy-js/core";
 import { expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { VarDeclaration } from "./declaration.jsx";
@@ -51,3 +51,18 @@ it("links refkey", () => {
       var testVar2 = testVar;
   `);
 });
+
+it("links namekey", () => {
+  const key = namekey("test-var");
+  expect(
+    <TestNamespace>
+      <List>
+        <VarDeclaration name={key}>42</VarDeclaration>
+        <VarDeclaration name="testVar2">{key}</VarDeclaration>
+      </List>
+    </TestNamespace>,
+  ).toRenderTo(`
+      var testVar = 42;
+      var testVar2 = testVar;
+  `);
+});

package/src/components/var/declaration.tsx

@@ -3,6 +3,7 @@ import {
   Declaration,
   DeclarationProps,
   Name,
+  Namekey,
   Refkey,
 } from "@alloy-js/core";
 import { createVariableSymbol } from "../../symbols/factories.js";
@@ -11,7 +12,7 @@ import { createVariableSymbol } from "../../symbols/factories.js";
 export interface VarDeclarationProps
   extends Omit<DeclarationProps, "nameKind"> {
   /** Variable name */
-  name: string;
+  name: string | Namekey;
   /** Type of the variable declaration. If not specified, defaults to "var" */
   type?: Children;
   /** Variable refkey */

package/src/name-policy.ts

@@ -17,7 +17,8 @@ export type CSharpElements =
   | "class-method"
   | "class-property"
   | "parameter"
-  | "type-parameter";
+  | "type-parameter"
+  | "namespace";
 
 // creates the C# naming policy
 export function createCSharpNamePolicy(): core.NamePolicy<CSharpElements> {
@@ -33,6 +34,7 @@ export function createCSharpNamePolicy(): core.NamePolicy<CSharpElements> {
       case "class-method":
       case "type-parameter":
       case "class-property":
+      case "namespace":
         return changecase.pascalCase(name);
       case "constant":
         return changecase.constantCase(name);

package/src/symbols/factories.ts

@@ -6,6 +6,7 @@ import {
   useBinder,
 } from "@alloy-js/core";
 import { getGlobalNamespace } from "../contexts/global-namespace.js";
+import { useNamespaceContext } from "../contexts/namespace.js";
 import { CSharpElements, useCSharpNamePolicy } from "../name-policy.js";
 import { CSharpClassScope } from "../scopes/class.js";
 import { useCSharpScope, useNamedTypeScope } from "../scopes/contexts.js";
@@ -13,10 +14,7 @@ import { CSharpScope } from "../scopes/csharp.js";
 import { CSharpLexicalScope } from "../scopes/lexical.js";
 import { CSharpMethodScope } from "../scopes/method.js";
 import { CSharpNamedTypeScope } from "../scopes/named-type.js";
-import {
-  CSharpNamespaceScope,
-  useEnclosingNamespaceScope,
-} from "../scopes/namespace.js";
+import { CSharpNamespaceScope } from "../scopes/namespace.js";
 import { CSharpSourceFileScope } from "../scopes/source-file.js";
 import { CSharpSymbol, CSharpSymbolOptions } from "./csharp.js";
 import { MethodKinds, MethodSymbol } from "./method.js";
@@ -118,13 +116,52 @@ export function createNamedTypeSymbol(
   );
 }
 
-export function createNamespaceSymbol(name: string) {
-  const scope = useEnclosingNamespaceScope();
-  const nsSymbol = scope?.ownerSymbol ?? getGlobalNamespace(useBinder());
-  if (nsSymbol.members.symbolNames.has(name)) {
-    return nsSymbol.members.symbolNames.get(name)! as NamespaceSymbol;
+export function createNamespaceSymbol(
+  name: string | Namekey | (string | Namekey)[],
+  options: CSharpSymbolOptions = {},
+): NamespaceSymbol {
+  const scope = useNamespaceContext();
+  const parentSymbol = scope?.symbol ?? getGlobalNamespace(useBinder());
+  const names = normalizeNamespaceName(name);
+  let current = parentSymbol;
+  for (const name of names) {
+    current = createNamespaceSymbolInternal(name, current, options);
+  }
+  return current;
+}
+
+function normalizeNamespaceName(
+  name: string | Namekey | (string | Namekey)[],
+): (string | Namekey)[] {
+  if (Array.isArray(name)) {
+    return name;
+  }
+  if (typeof name === "string" && name.includes(".")) {
+    return name.split(".");
   }
-  return withCleanup(new NamespaceSymbol(name, nsSymbol));
+  return [name];
+}
+
+function createNamespaceSymbolInternal(
+  name: string | Namekey,
+  parentSymbol: NamespaceSymbol,
+  options: CSharpSymbolOptions = {},
+): NamespaceSymbol {
+  const namePolicy =
+    options.namePolicy ?? useCSharpNamePolicy().for("namespace");
+  const expectedName = namePolicy(typeof name === "string" ? name : name.name);
+  if (parentSymbol.members.symbolNames.has(expectedName)) {
+    return parentSymbol.members.symbolNames.get(
+      expectedName,
+    )! as NamespaceSymbol;
+  }
+  return withCleanup(
+    new NamespaceSymbol(
+      name,
+      parentSymbol,
+      withNamePolicy(options, "namespace"),
+    ),
+  );
 }
 
 export interface CreateMethodSymbolOptions extends CSharpSymbolOptions {

package/src/symbols/namespace.ts

@@ -1,4 +1,4 @@
-import { OutputSymbolOptions } from "@alloy-js/core";
+import { Namekey, OutputSymbolOptions } from "@alloy-js/core";
 import { NamedTypeSymbol } from "./named-type.js";
 
 export interface NamespaceSymbolOptions extends OutputSymbolOptions {
@@ -11,7 +11,7 @@ export interface NamespaceSymbolOptions extends OutputSymbolOptions {
 export class NamespaceSymbol extends NamedTypeSymbol {
   public readonly symbolKind = "namespace";
   constructor(
-    name: string,
+    name: string | Namekey,
     parentNamespace?: NamespaceSymbol,
     options?: NamespaceSymbolOptions,
   ) {