@alloy-js/csharp 0.18.0-dev.24 → 0.18.0-dev.4

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

@@ -1,158 +0,0 @@
-import { List, refkey } from "@alloy-js/core";
-import { describe, expect, it } from "vitest";
-import { TestNamespace } from "../../../test/utils.jsx";
-import { Attribute } from "../attributes/attributes.jsx";
-import { SourceFile } from "../SourceFile.jsx";
-import { TypeParameterProps } from "../type-parameters/type-parameter.jsx";
-import { InterfaceDeclaration } from "./declaration.jsx";
-import { InterfaceProperty } from "./property.jsx";
-
-it("declares class with no members", () => {
-  expect(
-    <TestNamespace>
-      <InterfaceDeclaration name="TestInterface" />
-    </TestNamespace>,
-  ).toRenderTo(`
-      interface TestInterface;
-  `);
-});
-
-describe("modifiers", () => {
-  it.each(["public", "private", "internal"])("%s", (mod) => {
-    expect(
-      <TestNamespace>
-        <InterfaceDeclaration {...{ [mod]: true }} name="TestInterface" />
-      </TestNamespace>,
-    ).toRenderTo(`
-        ${mod} interface TestInterface;
-    `);
-  });
-
-  it.each(["partial"])("%s", (mod) => {
-    expect(
-      <TestNamespace>
-        <InterfaceDeclaration {...{ [mod]: true }} name="TestInterface" />
-      </TestNamespace>,
-    ).toRenderTo(`
-        ${mod} interface TestInterface;
-    `);
-  });
-
-  it("combines modifiers", () => {
-    expect(
-      <TestNamespace>
-        <InterfaceDeclaration public partial name="TestInterface" />
-      </TestNamespace>,
-    ).toRenderTo(`
-        public partial interface TestInterface;
-    `);
-  });
-});
-
-it("specify doc comment", () => {
-  expect(
-    <TestNamespace>
-      <InterfaceDeclaration name="TestInterface" doc="This is a test" />
-    </TestNamespace>,
-  ).toRenderTo(`
-    /// This is a test
-    interface TestInterface;
-  `);
-});
-
-describe("with type parameters", () => {
-  it("reference parameters", () => {
-    const typeParameters: TypeParameterProps[] = [
-      {
-        name: "T",
-        refkey: refkey(),
-      },
-      {
-        name: "U",
-        refkey: refkey(),
-      },
-    ];
-
-    expect(
-      <TestNamespace>
-        <SourceFile path="Test.cs">
-          <InterfaceDeclaration
-            public
-            name="Test"
-            typeParameters={typeParameters}
-          >
-            <List>
-              <InterfaceProperty
-                name="PropA"
-                type={typeParameters[0].refkey}
-                get
-                set
-              />
-              <InterfaceProperty
-                name="PropB"
-                type={typeParameters[1].refkey}
-                get
-                set
-              />
-            </List>
-          </InterfaceDeclaration>
-        </SourceFile>
-      </TestNamespace>,
-    ).toRenderTo(`
-      namespace TestCode
-      {
-        public interface Test<T, U>
-        {
-          T PropA { get; set; }
-          U PropB { get; set; }
-        }
-      }
-    `);
-  });
-
-  it("defines with constraints", () => {
-    const typeParameters: TypeParameterProps[] = [
-      {
-        name: "T",
-        constraints: "IFoo",
-      },
-      {
-        name: "U",
-        constraints: "IBar",
-      },
-    ];
-
-    expect(
-      <TestNamespace>
-        <InterfaceDeclaration
-          public
-          name="Test"
-          typeParameters={typeParameters}
-        >
-          // Body
-        </InterfaceDeclaration>
-      </TestNamespace>,
-    ).toRenderTo(`
-      public interface Test<T, U>
-        where T : IFoo
-        where U : IBar
-      {
-        // Body
-      }
-    `);
-  });
-});
-
-it("specify attributes", () => {
-  expect(
-    <TestNamespace>
-      <InterfaceDeclaration
-        name="Test"
-        attributes={[<Attribute name="Test" />]}
-      />
-    </TestNamespace>,
-  ).toRenderTo(`
-    [Test]
-    interface Test;
-  `);
-});

package/src/components/interface/declaration.tsx

@@ -1,125 +0,0 @@
-import * as core from "@alloy-js/core";
-import {
-  AccessModifiers,
-  computeModifiersPrefix,
-  getAccessModifier,
-  makeModifiers,
-} from "../../modifiers.js";
-import { useCSharpNamePolicy } from "../../name-policy.js";
-import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
-import { CSharpMemberScope } from "../../symbols/scopes.js";
-import { AttributeList, AttributesProp } from "../attributes/attributes.jsx";
-import { DocWhen } from "../doc/comment.jsx";
-import { Name } from "../Name.jsx";
-import { TypeParameterConstraints } from "../type-parameters/type-parameter-constraints.jsx";
-import { TypeParameterProps } from "../type-parameters/type-parameter.jsx";
-import { TypeParameters } from "../type-parameters/type-parameters.jsx";
-
-export interface InterfaceModifiers {
-  readonly partial?: boolean;
-}
-
-const getInterfaceModifiers = makeModifiers<InterfaceModifiers>(["partial"]);
-
-// properties for creating a class
-export interface InterfaceDeclarationProps
-  extends Omit<core.DeclarationProps, "nameKind">,
-    AccessModifiers,
-    InterfaceModifiers {
-  name: string;
-
-  /** Doc comment */
-  doc?: core.Children;
-  refkey?: core.Refkey;
-
-  /**
-   * Type parameters for the interface
-   *
-   * @example
-   * ```tsx
-   * <InterfaceDeclaration name="IList" typeParameters={["T"]} />
-   * ```
-   * This will produce:
-   * ```csharp
-   * public interface IList<T>
-   * ```
-   */
-  typeParameters?: (TypeParameterProps | string)[];
-
-  /**
-   * Define attributes to attach
-   * @example
-   * ```tsx
-   * <InterfaceDeclaration name="MyInterface" attributes={[
-   *  <Attribute name="Test" />
-   *  <Attribute name="Test2" args={["arg1", "arg2"]} />
-   * ]} />
-   * ```
-   * This will produce:
-   * ```csharp
-   * [Test]
-   * [Test2("arg1", "arg2")]
-   * public interface MyInterface
-   * ```
-   */
-  attributes?: AttributesProp;
-}
-
-/**
- * CSharp interface declaration.
- * @example
- * ```tsx
- * <InterfaceDeclaration public name="IMyInterface">
- *   <InterfaceMember public name="MyProperty" type="int" />
- *   <InterfaceMethod public name="MyMethod" returnType="void">
- *     <Parameter name="value" type="int" />
- *   </InterfaceMethod>
- * </InterfaceDeclaration>
- * ```
- * This will produce:
- * ```csharp
- * public interface MyIface
- * {
- *   public int MyProperty { get; set; }
- *   public void MyMethod(int value);
- * }
- * ```
- */
-export function InterfaceDeclaration(props: InterfaceDeclarationProps) {
-  const name = useCSharpNamePolicy().getName(props.name!, "interface");
-
-  const thisInterfaceSymbol = new CSharpOutputSymbol(name, {
-    refkeys: props.refkey,
-  });
-
-  // this creates a new scope for the interface definition.
-  // members will automatically "inherit" this scope so
-  // that refkeys to them will produce the fully-qualified
-  // name e.g. Foo.Bar.
-  const thisInterfaceScope = new CSharpMemberScope("interface-decl", {
-    owner: thisInterfaceSymbol,
-  });
-
-  const modifiers = computeModifiersPrefix([
-    getAccessModifier(props),
-    getInterfaceModifiers(props),
-  ]);
-  return (
-    <core.Declaration symbol={thisInterfaceSymbol}>
-      <DocWhen doc={props.doc} />
-      <AttributeList attributes={props.attributes} endline />
-      {modifiers}interface <Name />
-      {props.typeParameters && (
-        <TypeParameters parameters={props.typeParameters} />
-      )}
-      {props.typeParameters && (
-        <TypeParameterConstraints parameters={props.typeParameters} />
-      )}
-      {props.children ?
-        <core.Block newline>
-          <core.Scope value={thisInterfaceScope}>{props.children}</core.Scope>
-        </core.Block>
-      : ";"}
-    </core.Declaration>
-  );
-}

package/src/components/interface/method.test.tsx

@@ -1,293 +0,0 @@
-import { refkey } from "@alloy-js/core";
-import { Children } from "@alloy-js/core/jsx-runtime";
-import { describe, expect, it } from "vitest";
-import { TestNamespace } from "../../../test/utils.jsx";
-import { Attribute } from "../attributes/attributes.jsx";
-import { SourceFile } from "../SourceFile.jsx";
-import { TypeParameterProps } from "../type-parameters/type-parameter.jsx";
-import { InterfaceDeclaration } from "./declaration.jsx";
-import { InterfaceMethod } from "./method.jsx";
-
-const Wrapper = (props: { children: Children }) => (
-  <TestNamespace>
-    <InterfaceDeclaration public name="TestInterface">
-      {props.children}
-    </InterfaceDeclaration>
-  </TestNamespace>
-);
-
-describe("modifiers", () => {
-  describe("access modifiers", () => {
-    it.each(["public", "private", "protected", "internal"] as const)(
-      "%s",
-      (accessModifier) => {
-        expect(
-          <Wrapper>
-            <InterfaceMethod {...{ [accessModifier]: true }} name="MethodOne" />
-          </Wrapper>,
-        ).toRenderTo(`
-        public interface TestInterface
-        {
-          ${accessModifier} void MethodOne();
-        }
-      `);
-      },
-    );
-  });
-
-  describe("method modifiers", () => {
-    it.each(["new"] as const)("%s", (methodModifier) => {
-      expect(
-        <Wrapper>
-          <InterfaceMethod {...{ [methodModifier]: true }} name="MethodOne" />
-        </Wrapper>,
-      ).toRenderTo(`
-        public interface TestInterface
-        {
-          ${methodModifier} void MethodOne();
-        }
-      `);
-    });
-  });
-
-  it("combine modifiers", () => {
-    expect(
-      <Wrapper>
-        <InterfaceMethod returns="Task" public new name="MethodOne" />
-      </Wrapper>,
-    ).toRenderTo(`
-        public interface TestInterface
-        {
-          public new Task MethodOne();
-        }
-      `);
-  });
-});
-
-it("applies PascalCase naming policy", () => {
-  expect(
-    <Wrapper>
-      <InterfaceMethod name="method_one" />
-    </Wrapper>,
-  ).toRenderTo(`
-    public interface TestInterface
-    {
-      void MethodOne();
-    }
-`);
-});
-
-it("defines params and return type", () => {
-  const params = [
-    {
-      name: "intParam",
-      type: "int",
-    },
-    {
-      name: "stringParam",
-      type: "string",
-    },
-  ];
-  const res = (
-    <Wrapper>
-      <InterfaceMethod
-        public
-        name="MethodOne"
-        parameters={params}
-        returns="string"
-      />
-    </Wrapper>
-  );
-
-  expect(res).toRenderTo(`
-    public interface TestInterface
-    {
-      public string MethodOne(int intParam, string stringParam);
-    }
-  `);
-});
-
-it("defines optional param", () => {
-  const res = (
-    <Wrapper>
-      <InterfaceMethod
-        public
-        name="MethodOne"
-        parameters={[
-          {
-            name: "intParam",
-            type: "int",
-            optional: true,
-          },
-        ]}
-        returns="string"
-      />
-    </Wrapper>
-  );
-
-  expect(res).toRenderTo(`
-    public interface TestInterface
-    {
-      public string MethodOne(int? intParam);
-    }
-  `);
-});
-
-it("defines optional param with default", () => {
-  const res = (
-    <Wrapper>
-      <InterfaceMethod
-        public
-        name="MethodOne"
-        parameters={[
-          {
-            name: "intParam",
-            type: "int",
-            default: 12,
-          },
-        ]}
-        returns="string"
-      />
-    </Wrapper>
-  );
-
-  expect(res).toRenderTo(`
-    public interface TestInterface
-    {
-      public string MethodOne(int intParam = 12);
-    }
-  `);
-});
-
-it("specify doc comment", () => {
-  expect(
-    <TestNamespace>
-      <InterfaceDeclaration name="Test">
-        <InterfaceMethod name="Method" doc="This is a test" />
-      </InterfaceDeclaration>
-    </TestNamespace>,
-  ).toRenderTo(`
-    interface Test
-    {
-      /// This is a test
-      void Method();
-    }
-  `);
-});
-
-it("specify attributes", () => {
-  expect(
-    <Wrapper>
-      <InterfaceMethod name="Test" attributes={[<Attribute name="Test" />]} />
-    </Wrapper>,
-  ).toRenderTo(`
-    public interface TestInterface
-    {
-      [Test]
-      void Test();
-    }
-  `);
-});
-
-describe("with type parameters", () => {
-  it("reference parameters", () => {
-    const typeParameters: TypeParameterProps[] = [
-      {
-        name: "T",
-        refkey: refkey(),
-      },
-      {
-        name: "U",
-        refkey: refkey(),
-      },
-    ];
-
-    expect(
-      <TestNamespace>
-        <SourceFile path="TestFile.cs">
-          <InterfaceDeclaration public name="TestInterface">
-            <InterfaceMethod
-              name="Test"
-              public
-              typeParameters={typeParameters}
-              parameters={[
-                {
-                  name: "paramA",
-                  type: typeParameters[0].refkey,
-                },
-              ]}
-              returns={typeParameters[0].refkey}
-            />
-          </InterfaceDeclaration>
-        </SourceFile>
-      </TestNamespace>,
-    ).toRenderTo(`
-      namespace TestCode
-      {
-        public interface TestInterface
-        {
-          public T Test<T, U>(T paramA);
-        }
-      }
-    `);
-  });
-
-  it("defines with constraints", () => {
-    const typeParameters: TypeParameterProps[] = [
-      {
-        name: "T",
-        constraints: "IFoo",
-      },
-      {
-        name: "U",
-        constraints: "IBar",
-      },
-    ];
-
-    expect(
-      <Wrapper>
-        <InterfaceMethod public name="Test" typeParameters={typeParameters}>
-          // Body
-        </InterfaceMethod>
-      </Wrapper>,
-    ).toRenderTo(`
-      public interface TestInterface
-      {
-        public void Test<T, U>()
-          where T : IFoo
-          where U : IBar
-        {
-          // Body
-        }
-      }
-    `);
-  });
-});
-
-describe("formatting", () => {
-  it("Split parameters before type parameters", () => {
-    expect(
-      <Wrapper>
-        <InterfaceMethod
-          public
-          name="Handle"
-          parameters={[
-            {
-              name: "message",
-              type: "Some.Quite.Long.Type.That.Will.Split",
-            },
-          ]}
-          typeParameters={["T"]}
-          returns="Some.Quite.Long.Type.That.Will.Split"
-        />
-      </Wrapper>,
-    ).toRenderTo(`
-      public interface TestInterface
-      {
-        public Some.Quite.Long.Type.That.Will.Split Handle<T>(
-          Some.Quite.Long.Type.That.Will.Split message
-        );
-      }
-    `);
-  });
-});

package/src/components/interface/method.tsx

@@ -1,122 +0,0 @@
-import {
-  Block,
-  Children,
-  MemberDeclaration,
-  refkey,
-  Refkey,
-  Scope,
-} from "@alloy-js/core";
-import {
-  AccessModifiers,
-  computeModifiersPrefix,
-  getAccessModifier,
-  makeModifiers,
-} from "../../modifiers.js";
-import { useCSharpNamePolicy } from "../../name-policy.js";
-import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
-import { CSharpMemberScope, useCSharpScope } from "../../symbols/scopes.js";
-import { AttributeList, AttributesProp } from "../attributes/attributes.jsx";
-import { DocWhen } from "../doc/comment.jsx";
-import { ParameterProps, Parameters } from "../parameters/parameters.jsx";
-import { TypeParameterConstraints } from "../type-parameters/type-parameter-constraints.jsx";
-import { TypeParameterProps } from "../type-parameters/type-parameter.jsx";
-import { TypeParameters } from "../type-parameters/type-parameters.jsx";
-
-/** Method modifiers. Can only be one. */
-export interface InterfaceMethodModifiers {
-  readonly new?: boolean;
-}
-
-const getMethodModifier = makeModifiers<InterfaceMethodModifiers>(["new"]);
-
-// properties for creating a method
-export interface InterfaceMethodProps
-  extends AccessModifiers,
-    InterfaceMethodModifiers {
-  name: string;
-  refkey?: Refkey;
-  children?: Children;
-  parameters?: Array<ParameterProps>;
-  /**
-   * Type parameters for the method
-   *
-   * @example
-   * ```tsx
-   * <InterfaceMethod name="Test" typeParameters={["T"]} />
-   * ```
-   * This will produce:
-   * ```csharp
-   * public void Test<T>()
-   * ```
-   */
-  typeParameters?: (TypeParameterProps | string)[];
-  returns?: Children;
-
-  /** Doc comment */
-  doc?: Children;
-
-  /**
-   * Define attributes to attach
-   * @example
-   * ```tsx
-   * <InterfaceMethod name="MyMethod" attributes={[
-   *  <Attribute name="Test" />
-   *  <Attribute name="Test2" args={["arg1", "arg2"]} />
-   * ]} />
-   * ```
-   * This will produce:
-   * ```csharp
-   * [Test]
-   * [Test2("arg1", "arg2")]
-   * void MyMethod();
-   * ```
-   */
-  attributes?: AttributesProp;
-}
-
-// a C# interface method
-export function InterfaceMethod(props: InterfaceMethodProps) {
-  const name = useCSharpNamePolicy().getName(props.name, "class-method");
-  const scope = useCSharpScope();
-  if (scope.kind !== "member" || scope.name !== "interface-decl") {
-    throw new Error(
-      "can't define an interface method outside of an interface scope",
-    );
-  }
-
-  const methodSymbol = new CSharpOutputSymbol(name, {
-    scope,
-    refkeys: props.refkey ?? refkey(props.name),
-  });
-
-  // scope for method declaration
-  const methodScope = new CSharpMemberScope("method-decl", {
-    owner: methodSymbol,
-  });
-
-  const modifiers = computeModifiersPrefix([
-    getAccessModifier(props),
-    getMethodModifier(props),
-  ]);
-  // note that scope wraps the method decl so that the params get the correct scope
-  return (
-    <MemberDeclaration symbol={methodSymbol}>
-      <Scope value={methodScope}>
-        <DocWhen doc={props.doc} />
-        <AttributeList attributes={props.attributes} endline />
-        {modifiers}
-        {props.returns ?? "void"} {name}
-        {props.typeParameters && (
-          <TypeParameters parameters={props.typeParameters} />
-        )}
-        <Parameters parameters={props.parameters} />
-        {props.typeParameters && (
-          <TypeParameterConstraints parameters={props.typeParameters} />
-        )}
-        {props.children ?
-          <Block newline>{props.children}</Block>
-        : ";"}
-      </Scope>
-    </MemberDeclaration>
-  );
-}