@alloy-js/csharp 0.21.0-dev.0 → 0.21.0-dev.12

package/src/components/{namespace.tsx → namespace/namespace.tsx}

@@ -1,17 +1,21 @@
-import { Block } from "@alloy-js/core";
+import { Block, Namekey, Refkey } from "@alloy-js/core";
 import { Children } from "@alloy-js/core/jsx-runtime";
-import { NamespaceContext } from "../contexts/namespace.js";
-import { useSourceFileScope } from "../scopes/source-file.js";
-import { createNamespaceSymbol } from "../symbols/factories.js";
-import { NamespaceScope } from "./namespace-scopes.jsx";
+import { NamespaceContext } from "../../contexts/namespace.js";
+import { useSourceFileScope } from "../../scopes/source-file.js";
+import { createNamespaceSymbol } from "../../symbols/factories.js";
+import { NamespaceScope } from "../namespace-scopes.jsx";
+import { NamespaceName } from "./namespace-name.jsx";
 
 export interface NamespaceProps {
-  name: string;
+  name: string | Namekey | (string | Namekey)[];
+  refkey?: Refkey | Refkey[];
   children?: Children;
 }
 
 export function Namespace(props: NamespaceProps) {
-  const namespaceSymbol = createNamespaceSymbol(props.name);
+  const namespaceSymbol = createNamespaceSymbol(props.name, {
+    refkeys: props.refkey,
+  });
   const sfScope = useSourceFileScope();
 
   if (!sfScope) {
@@ -24,7 +28,7 @@ export function Namespace(props: NamespaceProps) {
     sfScope.hasBlockNamespace = true;
     return (
       <>
-        namespace {namespaceSymbol.name}{" "}
+        namespace <NamespaceName symbol={namespaceSymbol} relative />{" "}
         <Block>
           <NamespaceContext.Provider value={{ symbol: namespaceSymbol }}>
             <NamespaceScope symbol={namespaceSymbol}>
@@ -36,10 +40,3 @@ export function Namespace(props: NamespaceProps) {
     );
   }
 }
-
-/*
-  const scope = createCSharpNamespaceScope(namespaceSymbol);
-
-  return <Scope value={scope}>{props.children}</Scope>;
-}
-  */

package/src/components/namespace.ref.test.tsx

@@ -1,8 +1,7 @@
-import { Output, refkey } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
+import { List, memberRefkey, namekey, Output, refkey } from "@alloy-js/core";
 import { expect, it } from "vitest";
 import { ClassDeclaration } from "./class/declaration.jsx";
-import { Namespace } from "./namespace.jsx";
+import { Namespace } from "./namespace/namespace.jsx";
 import { SourceFile } from "./source-file/source-file.jsx";
 
 it("references types in the same namespace", () => {
@@ -20,7 +19,7 @@ it("references types in the same namespace", () => {
     </Output>
   );
 
-  expect(tree).toRenderTo(d`
+  expect(tree).toRenderTo(`
     namespace Test;
 
     class TestClass;
@@ -43,7 +42,7 @@ it("references types in a parent namespace", () => {
     </Output>
   );
 
-  expect(tree).toRenderTo(d`
+  expect(tree).toRenderTo(`
     namespace Test {
         class TestClass;
         namespace Nested {
@@ -69,7 +68,7 @@ it("references types in a child namespace", () => {
     </Output>
   );
 
-  expect(tree).toRenderTo(d`
+  expect(tree).toRenderTo(`
     namespace Test {
         Nested.TestClass;
         namespace Nested {
@@ -94,7 +93,7 @@ it("references types in a different top-level namespace declared in the same fil
     </Output>
   );
 
-  expect(tree).toRenderTo(d`
+  expect(tree).toRenderTo(`
     using TestCode2;
 
     namespace TestCode1 {
@@ -123,17 +122,43 @@ it("references types in a different top-level namespace declared in a different
   );
 
   expect(tree).toRenderTo({
-    "test.cs": d`
+    "test.cs": `
       using TestCode2;
 
       namespace TestCode1 {
           TestClass;
       }
     `,
-    "other.cs": d`
+    "other.cs": `
         namespace TestCode2 {
             class TestClass;
         }
       `,
   });
 });
+
+it("can be referenced by refkey", () => {
+  const classRef = namekey("TestClass");
+  const nsRef = namekey("TestCode2");
+  const tree = (
+    <Output>
+      <SourceFile path="other.cs">
+        <List>
+          <Namespace name={nsRef}>
+            <ClassDeclaration name={classRef} />
+          </Namespace>
+          <>{memberRefkey(nsRef, classRef)};</>
+        </List>
+      </SourceFile>
+    </Output>
+  );
+
+  expect(tree).toRenderTo(`
+    using TestCode2;
+
+    namespace TestCode2 {
+        class TestClass;
+    }
+    TestClass;
+  `);
+});

package/src/components/parameters/parameters.tsx

@@ -51,9 +51,14 @@ export function Parameters(props: ParametersProps) {
     <group>
       {"("}
       {props.parameters && (
-        <Indent softline>
+        <Indent nobreak>
           <For each={props.parameters} joiner={", "}>
-            {(param) => <Parameter {...param} />}
+            {(param) => (
+              <>
+                <softline />
+                <Parameter {...param} />
+              </>
+            )}
           </For>
         </Indent>
       )}

package/src/components/property/property.test.tsx

@@ -207,3 +207,28 @@ it("specify attributes", () => {
     }
   `);
 });
+
+describe("format", () => {
+  it("split after = if initializer too long", () => {
+    expect(
+      <TestNamespace printWidth={60}>
+        <ClassDeclaration name="Test">
+          <Property
+            public
+            get
+            set
+            name="ThisIsAVeryLongPropertyName"
+            type="string"
+            initializer={`"Some very long initializer value"`}
+          />
+        </ClassDeclaration>
+      </TestNamespace>,
+    ).toRenderTo(`
+      class Test
+      {
+          public string ThisIsAVeryLongPropertyName { get; set; } =
+              "Some very long initializer value";
+      }
+  `);
+  });
+});

package/src/components/property/property.tsx

@@ -1,7 +1,5 @@
 import {
-  Block,
   Children,
-  code,
   createSymbolSlot,
   List,
   MemberDeclaration,
@@ -142,15 +140,28 @@ export function Property(props: PropertyProps) {
       <AttributeList attributes={props.attributes} endline />
       {modifiers}
       <TypeSlot>{props.type}</TypeSlot>
-      {props.nullable && "?"} <MemberName />{" "}
-      <Block newline inline>
-        <List joiner=" ">
-          {props.get && "get;"}
-          {props.set && "set;"}
-          {props.init && "init;"}
-        </List>
-      </Block>
-      {props.initializer && code` = ${props.initializer};`}
+      {props.nullable && "?"} <MemberName /> {"{ "}
+      <List joiner=" ">
+        {props.get && "get;"}
+        {props.set && "set;"}
+        {props.init && "init;"}
+      </List>
+      {" }"}
+      {props.initializer && (
+        <PropertyInitializer>{props.initializer}</PropertyInitializer>
+      )}
     </MemberDeclaration>
   );
 }
+
+function PropertyInitializer(props: { children: Children }) {
+  return (
+    <group>
+      {" ="}
+      <indent>
+        <line />
+        {props.children};
+      </indent>
+    </group>
+  );
+}

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

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

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,6 +1,7 @@
 import { NamespaceScopes } from "#components/namespace-scopes.jsx";
+import { NamespaceName } from "#components/namespace/namespace-name.jsx";
 import { Reference } from "#components/Reference.jsx";
-import { UsingDirective } from "#components/UsingDirective.jsx";
+import { Usings } from "#components/using/using.jsx";
 import {
   Block,
   Children,
@@ -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)[]
@@ -70,7 +70,7 @@ export function SourceFile(props: SourceFileProps) {
         {(sourceFileScope.usings.size > 0 ||
           (props.using && props.using.length > 0)) && (
           <>
-            <UsingDirective namespaces={usings.value} />
+            <Usings namespaces={usings.value} />
             <hbr />
             <hbr />
           </>
@@ -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

@@ -0,0 +1,94 @@
+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/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";
+import { expect, it } from "vitest";
+import { createCSharpNamePolicy } from "../../name-policy.js";
+
+it("using on source file are placed above file namespace statement", () => {
+  expect(
+    <Output>
+      <Namespace name="TestCode">
+        <SourceFile path="Test1.cs" using={["Foo"]} />
+      </Namespace>
+    </Output>,
+  ).toRenderTo(`
+    using Foo;
+
+    namespace TestCode;
+
+    
+  `);
+});
+
+it("adds using statement across namespaces", () => {
+  const inputTypeRefkey = refkey();
+  const outputTypeRefkey = refkey();
+  const twoValRefkey = refkey();
+
+  const params = [
+    {
+      name: "BodyParam",
+      type: inputTypeRefkey,
+    },
+  ];
+
+  expect(
+    <Output namePolicy={createCSharpNamePolicy()}>
+      <Namespace name="Models">
+        <SourceFile path="Models.cs">
+          <ClassDeclaration public name="Input" refkey={inputTypeRefkey} />
+          <hbr />
+          <ClassDeclaration public name="Output" refkey={outputTypeRefkey} />
+          <hbr />
+          <EnumDeclaration public name="TestEnum">
+            <EnumMember name="One" />,<hbr />
+            <EnumMember name="Two" refkey={twoValRefkey} />
+          </EnumDeclaration>
+        </SourceFile>
+      </Namespace>
+      <Namespace name="Client">
+        <SourceFile path="Client.cs" using={["System"]}>
+          <ClassDeclaration public name="Client">
+            <Method
+              public
+              name="MethodOne"
+              parameters={params}
+              returns={outputTypeRefkey}
+            />
+          </ClassDeclaration>
+          <hbr />
+          {twoValRefkey};
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  ).toRenderTo({
+    "Models.cs": coretest.d`
+      namespace Models;
+
+      public class Input;
+      public class Output;
+      public enum TestEnum
+      {
+          One,
+          Two
+      }
+    `,
+    "Client.cs": coretest.d`
+      using Models;
+      using System;
+
+      namespace Client;
+      
+      public class Client
+      {
+          public Output MethodOne(Input bodyParam) {}
+      }
+      TestEnum.Two;
+    `,
+  });
+});

package/src/components/stc/index.ts

@@ -10,5 +10,5 @@ export const EnumMember = core.stc(base.EnumMember);
 export const Parameter = core.stc(base.Parameter);
 export const Parameters = core.stc(base.Parameters);
 export const ProjectDirectory = core.stc(base.ProjectDirectory);
-export const UsingDirective = core.stc(base.UsingDirective);
+export const UsingDirective = core.stc(base.Usings);
 export const StructDeclaration = core.stc(base.StructDeclaration);

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/using/using.test.tsx

@@ -0,0 +1,15 @@
+import { expect, it } from "vitest";
+import { Usings } from "./using.jsx";
+
+it("single using", () => {
+  expect(<Usings namespaces={["Foo"]} />).toRenderTo(`
+    using Foo;
+  `);
+});
+
+it("multiple using", () => {
+  expect(<Usings namespaces={["Foo", "Bar"]} />).toRenderTo(`
+    using Bar;
+    using Foo;
+  `);
+});

package/src/components/using/using.tsx

@@ -0,0 +1,52 @@
+import { computed, For } from "@alloy-js/core";
+import { NamespaceSymbol } from "../../symbols/namespace.js";
+
+export interface UsingsProps {
+  /**
+   * Namespace symbols or namespace names to use to generate using statements.
+   */
+  namespaces: (NamespaceSymbol | string)[];
+}
+
+/**
+ * Component rendering csharp using directive
+ * @example
+ *
+ * ```tsx
+ * <Usings namespaces={["System", "Models"]} />
+ * ```
+ *
+ * will render
+ *
+ * ```csharp
+ * using Models;
+ * using System;
+ * ```
+ */
+export function Usings(props: UsingsProps) {
+  const sortedNamespaces = computed(() => {
+    return props.namespaces
+      .map(getNamespaceName)
+      .sort((n1, n2) => n1.localeCompare(n2));
+  });
+
+  return (
+    <For each={sortedNamespaces}>
+      {(namespace) => <UsingNamespaceDirective namespace={namespace} />}
+    </For>
+  );
+}
+
+export interface UsingNamespaceDirective {
+  namespace: string;
+}
+
+export function UsingNamespaceDirective(props: UsingNamespaceDirective) {
+  return `using ${getNamespaceName(props.namespace)};`;
+}
+
+function getNamespaceName(namespace: string | NamespaceSymbol): string {
+  return typeof namespace === "string" ? namespace : (
+      namespace.getFullyQualifiedName({ omitGlobal: true })
+    );
+}

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

@@ -1,8 +1,10 @@
 import {
   Children,
+  createSymbolSlot,
   Declaration,
   DeclarationProps,
   Name,
+  Namekey,
   Refkey,
 } from "@alloy-js/core";
 import { createVariableSymbol } from "../../symbols/factories.js";
@@ -11,13 +13,16 @@ 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 */
   refkey?: Refkey;
   /** Variable value */
   children?: Children;
+
+  /** Constant variable. Add the const modifier. */
+  const?: boolean;
 }
 
 /**
@@ -42,12 +47,22 @@ export interface VarDeclarationProps
  * ```
  */
 export function VarDeclaration(props: VarDeclarationProps) {
+  const TypeSlot = createSymbolSlot();
+  const ValueSlot = createSymbolSlot();
+
   const sym = createVariableSymbol(props.name, {
     refkeys: props.refkey,
+    type: props.type ? TypeSlot.firstSymbol : ValueSlot.firstSymbol,
   });
+
+  if (props.const && !props.type) {
+    throw new Error("Implicitly-typed variables cannot be constant");
+  }
   return (
     <Declaration symbol={sym}>
-      {props.type ?? "var"} <Name /> = {props.children};
+      {props.const ? "const " : ""}
+      <TypeSlot>{props.type ?? "var"}</TypeSlot> <Name /> ={" "}
+      <ValueSlot>{props.children}</ValueSlot>;
     </Declaration>
   );
 }

package/src/contexts/global-namespace.ts

@@ -7,9 +7,16 @@ export function useGlobalNamespace() {
 }
 
 const globalNamespaces = new WeakMap<Binder, NamespaceSymbol>();
-const defaultGlobalNamespace = new NamespaceSymbol("global", undefined, {
+let defaultGlobalNamespace = new NamespaceSymbol("global", undefined, {
   isGlobal: true,
 });
+
+export function resetGlobalNamespace() {
+  defaultGlobalNamespace = new NamespaceSymbol("global", undefined, {
+    isGlobal: true,
+  });
+}
+
 export function getGlobalNamespace(binder: Binder | undefined) {
   if (!binder) {
     return defaultGlobalNamespace;