@alloy-js/csharp 0.20.0-dev.6 → 0.20.0-dev.9

package/src/components/access-expression/part-descriptors.ts

@@ -0,0 +1,175 @@
+import {
+  Children,
+  computed,
+  isComponentCreator,
+  reactive,
+  ref,
+  symbolForRefkey,
+  ToRefs,
+} from "@alloy-js/core";
+import { CSharpSymbol } from "../../index.js";
+import {
+  AccessExpression,
+  AccessExpressionPartProps,
+} from "./access-expression.jsx";
+
+export interface PartDescriptorWithId extends PartDescriptorBase {
+  /**
+   * The identifier of the access expression part. Will use member access, so must be a valid
+   * C# identifier.
+   */
+  id: Children;
+  conditional: boolean;
+  typeArgs?: Children[];
+}
+
+export function isIdPart(part: PartDescriptor): part is PartDescriptorWithId {
+  return "id" in part && part.id !== undefined;
+}
+
+export interface PartDescriptorWithIndex extends PartDescriptorBase {
+  /**
+   * The index of the access expression part. Will use element access.
+   */
+  indexerArgs: Children[];
+  conditional: boolean;
+}
+
+export function isIndexPart(
+  part: PartDescriptor,
+): part is PartDescriptorWithIndex {
+  return "indexerArgs" in part && part.indexerArgs !== undefined;
+}
+
+export interface PartDescriptorWithArgs extends PartDescriptorBase {
+  args: Children[];
+}
+
+export function isArgsPart(
+  part: PartDescriptor,
+): part is PartDescriptorWithArgs {
+  return "args" in part && part.args !== undefined;
+}
+
+export interface PartDescriptorBase {
+  nullable: boolean;
+}
+
+export type PartDescriptor =
+  | PartDescriptorWithId
+  | PartDescriptorWithIndex
+  | PartDescriptorWithArgs;
+
+/**
+ * Build part descriptors from the children of a MemberExpression.
+ */
+export function childrenToPartDescriptors(
+  children: Children[],
+): PartDescriptor[] {
+  const parts: PartDescriptor[] = [];
+  for (const child of children) {
+    if (!isComponentCreator(child, AccessExpression.Part)) {
+      // we ignore non-parts
+      continue;
+    }
+
+    parts.push(
+      createPartDescriptorFromProps(child.props, child === children[0]),
+    );
+  }
+
+  return parts;
+}
+
+const exclusiveParts: (keyof AccessExpressionPartProps)[] = [
+  "children",
+  "args",
+  "refkey",
+  "symbol",
+  "id",
+];
+/**
+ * Creates a reactive part descriptor from the given part props.
+ *
+ * @param partProps The props for the part.
+ * @param first Whether this is the first part in the expression. Refkeys are
+ * handled specially for the first part.
+ */
+function createPartDescriptorFromProps(
+  partProps: AccessExpressionPartProps,
+  first: boolean,
+) {
+  const foundProps = exclusiveParts.filter((key) => {
+    return key in partProps;
+  });
+
+  if (foundProps.length > 1) {
+    throw new Error(
+      `Only one of ${foundProps.join(", ")} can be used for a MemberExpression part at a time`,
+    );
+  }
+
+  const symbolSource = computed(() => {
+    if (partProps.refkey) {
+      return symbolForRefkey(partProps.refkey).value as CSharpSymbol;
+    } else if (partProps.symbol) {
+      return partProps.symbol;
+    } else {
+      return undefined;
+    }
+  });
+
+  const part: ToRefs<PartDescriptor> = {
+    id: computed(() => {
+      if (partProps.args || partProps.index || partProps.indexerArgs) {
+        return undefined;
+      } else if (partProps.children !== undefined) {
+        return partProps.children;
+      } else if (first && partProps.refkey) {
+        return partProps.refkey;
+      } else if (partProps.id !== undefined) {
+        return partProps.id;
+      } else if (symbolSource.value) {
+        return escapeId(symbolSource.value.name);
+      } else {
+        return "<unresolved symbol>";
+      }
+    }),
+    indexerArgs: computed(() => {
+      if (partProps.indexerArgs) {
+        return partProps.indexerArgs;
+      }
+
+      if (partProps.index !== undefined) {
+        return [partProps.index];
+      }
+
+      return [];
+    }),
+    conditional: computed(() => {
+      return !!partProps.conditional;
+    }),
+    nullable: computed(() => {
+      if (partProps.nullable) {
+        return true;
+      }
+
+      if (symbolSource.value) {
+        return symbolSource.value.isNullable;
+      }
+
+      return false;
+    }),
+    args: ref<any>(partProps.args === true ? [] : partProps.args),
+    typeArgs: ref<any>(partProps.typeArgs),
+  };
+
+  return reactive(part);
+}
+
+/**
+ * replaces quotes with escaped quotes
+ */
+function escapeId(id: string) {
+  return id.replace(/"/g, '\\"');
+}

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

@@ -19,7 +19,7 @@ import { Attribute } from "../attributes/attributes.jsx";
 import { Field } from "../field/field.jsx";
 import { Method } from "../method/method.jsx";
 import { Property } from "../property/property.jsx";
-import { SourceFile } from "../SourceFile.jsx";
+import { SourceFile } from "../source-file/source-file.jsx";
 import { TypeParameterProps } from "../type-parameters/type-parameter.jsx";
 import { ClassDeclaration } from "./declaration.jsx";
 

package/src/components/enum/declaration.ref.test.tsx

@@ -1,5 +1,5 @@
 import { Namespace } from "#components/namespace.jsx";
-import { SourceFile } from "#components/SourceFile.jsx";
+import { SourceFile } from "#components/source-file/source-file.jsx";
 import { Output, refkey } from "@alloy-js/core";
 import { d } from "@alloy-js/core/testing";
 import { expect, it } from "vitest";

package/src/components/index.ts

@@ -10,6 +10,7 @@ export * from "./field/field.jsx";
 export * from "./interface/declaration.js";
 export * from "./interface/method.js";
 export * from "./interface/property.js";
+export * from "./invocation-expression/invocation-expression.jsx";
 export * from "./lexical-scope.jsx";
 export * from "./method-scope.jsx";
 export * from "./method/method.jsx";
@@ -20,7 +21,7 @@ export * from "./ProjectDirectory.js";
 export * from "./property/property.jsx";
 export * from "./record/declaration.js";
 export * from "./Reference.js";
-export * from "./SourceFile.js";
+export * from "./source-file/source-file.jsx";
 export * from "./struct/declaration.jsx";
 export type { TypeParameterProps } from "./type-parameters/type-parameter.jsx";
 export * from "./UsingDirective.js";

package/src/components/invocation-expression/invocation-expression.test.tsx

@@ -0,0 +1,101 @@
+import { ClassDeclaration } from "#components/class/declaration.jsx";
+import { Method } from "#components/method/method.jsx";
+import { TestNamespace } from "#test/utils.jsx";
+import { namekey } from "@alloy-js/core";
+import { describe, expect, it } from "vitest";
+import { InvocationExpression } from "./invocation-expression.jsx";
+
+it("makes a call with no arguments", () => {
+  const template = <InvocationExpression target="Foo" />;
+  expect(template).toRenderTo(`Foo()`);
+});
+
+it("makes a call with arguments", () => {
+  const template = (
+    <InvocationExpression target="Foo" args={["42", `"string"`]} />
+  );
+  expect(template).toRenderTo(`Foo(42, "string")`);
+});
+
+it("makes a call with type parameters", () => {
+  const template = (
+    <InvocationExpression target="Foo" typeArgs={["Bar", "Baz"]} />
+  );
+  expect(template).toRenderTo(`Foo<Bar, Baz>()`);
+});
+
+it("makes a call to a method", () => {
+  const cls = namekey("TestClass");
+  const method = namekey("Method");
+  const template = (
+    <TestNamespace>
+      <ClassDeclaration name={cls}>
+        <Method name={method}>return 1;</Method>
+      </ClassDeclaration>
+      <hbr />
+      <InvocationExpression target={method} />;
+    </TestNamespace>
+  );
+  expect(template).toRenderTo(`
+    class TestClass
+    {
+        void Method()
+        {
+            return 1;
+        }
+    }
+    TestClass.Method();
+  `);
+});
+
+describe("formatting", () => {
+  it("doesn't break one long argument", () => {
+    const template = (
+      <InvocationExpression target="Foo" args={["oneLongArgument"]} />
+    );
+    expect(template).toRenderTo(`Foo(oneLongArgument)`, { printWidth: 10 });
+  });
+
+  it("breaks multiple arguments", () => {
+    const template = (
+      <InvocationExpression
+        target="Foo"
+        args={["oneLongArgument", "anotherLongArgument"]}
+      />
+    );
+    expect(template).toRenderTo(
+      `
+      Foo(
+        oneLongArgument,
+        anotherLongArgument
+      )
+      `,
+      { printWidth: 10 },
+    );
+  });
+
+  it("doesn't break one long type argument", () => {
+    const template = (
+      <InvocationExpression target="Foo" typeArgs={["oneLongArgument"]} />
+    );
+    expect(template).toRenderTo(`Foo<oneLongArgument>()`, { printWidth: 10 });
+  });
+
+  it("breaks multiple type arguments", () => {
+    const template = (
+      <InvocationExpression
+        target="Foo"
+        typeArgs={["oneLongArgument", "anotherLongArgument"]}
+      />
+    );
+    expect(template).toRenderTo(
+      `
+      Foo<
+        oneLongArgument,
+        anotherLongArgument
+      >()
+      `,
+      { printWidth: 10 },
+    );
+  });
+});

package/src/components/invocation-expression/invocation-expression.tsx

@@ -0,0 +1,60 @@
+import { Children, For, Indent, Show, Wrap } from "@alloy-js/core";
+
+export interface InvocationExpressionProps {
+  target: Children;
+  /**
+   * Arguments to pass to the invocation.
+   */
+  args?: Children[];
+  /**
+   * Generic type arguments for the invocation.
+   */
+  typeArgs?: Children[];
+}
+
+/**
+ * A call to a function or method.
+ *
+ * @example
+ *
+ * ```jsx
+ * <InvocationExpression target="Foo" typeArgs={["T"]} args={["x"]} />
+ * ```
+ *
+ * Renders to:
+ *
+ * ```csharp
+ * Foo<T>("x");
+ * ```
+ */
+export function InvocationExpression(props: InvocationExpressionProps) {
+  return (
+    <group>
+      {props.target}
+      <Show when={!!props.typeArgs && props.typeArgs.length > 0}>
+        {"<"}
+        <Wrap
+          when={props.typeArgs!.length > 1}
+          with={Indent}
+          props={{ softline: true, trailingBreak: true }}
+        >
+          <For each={props.typeArgs ?? []} comma line>
+            {(typeArg) => typeArg}
+          </For>
+        </Wrap>
+        {">"}
+      </Show>
+      (
+      <Wrap
+        when={!!props.args && props.args.length > 1}
+        with={Indent}
+        props={{ softline: true, trailingBreak: true }}
+      >
+        <For each={props.args ?? []} comma line>
+          {(arg) => arg}
+        </For>
+      </Wrap>
+      )
+    </group>
+  );
+}

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

@@ -3,7 +3,7 @@ import { d } from "@alloy-js/core/testing";
 import { expect, it } from "vitest";
 import { ClassDeclaration } from "./class/declaration.jsx";
 import { Namespace } from "./namespace.jsx";
-import { SourceFile } from "./SourceFile.jsx";
+import { SourceFile } from "./source-file/source-file.jsx";
 
 it("references types in the same namespace", () => {
   const classRef = refkey();

package/src/components/namespace.test.tsx

@@ -3,7 +3,7 @@ import { d } from "@alloy-js/core/testing";
 import { expect, it } from "vitest";
 import { ClassDeclaration } from "./class/declaration.jsx";
 import { Namespace } from "./namespace.jsx";
-import { SourceFile } from "./SourceFile.jsx";
+import { SourceFile } from "./source-file/source-file.jsx";
 
 it("defines multiple namespaces and source files with unique content", () => {
   const tree = (

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

@@ -1,5 +1,6 @@
 import { ClassDeclaration } from "#components/class/declaration.jsx";
 import { Method } from "#components/method/method.jsx";
+import { Property } from "#components/property/property.jsx";
 import { List, memberRefkey, namekey } from "@alloy-js/core";
 import { Children } from "@alloy-js/core/jsx-runtime";
 import { expect, it } from "vitest";
@@ -69,3 +70,48 @@ it("members can be referenced", () => {
     }
   `);
 });
+
+it("members can be referenced when the parameter is nullable", () => {
+  const propTypeKey = namekey("PropType");
+  const propTypePropKey = namekey("Field");
+  const classKey = namekey("TestType");
+  const propKey = namekey("TestProp");
+  const param1Key = namekey("param1");
+
+  expect(
+    <TestNamespace>
+      <List>
+        <ClassDeclaration name={propTypeKey}>
+          <Property name={propTypePropKey} type={"string"} nullable />
+        </ClassDeclaration>
+        <ClassDeclaration name={classKey}>
+          <Property name={propKey} type={propTypeKey} nullable />
+        </ClassDeclaration>
+        <ClassDeclaration name="Test">
+          <Method
+            name="Test"
+            parameters={[{ name: param1Key, type: classKey, optional: true }]}
+          >
+            return {memberRefkey(param1Key, propKey, propTypePropKey)};
+          </Method>
+        </ClassDeclaration>
+      </List>
+    </TestNamespace>,
+  ).toRenderTo(`
+      class PropType
+      {
+          string? Field {  }
+      }
+      class TestType
+      {
+          PropType? TestProp {  }
+      }
+      class Test
+      {
+          void Test(TestType? param1)
+          {
+              return param1?.TestProp?.Field;
+          }
+      }
+  `);
+});

package/src/components/parameters/parameters.tsx

@@ -6,7 +6,6 @@ import {
   For,
   Indent,
   Namekey,
-  OutputSymbol,
   Refkey,
 } from "@alloy-js/core";
 import { createParameterSymbol } from "../../symbols/factories.js";
@@ -19,8 +18,8 @@ export interface ParameterProps {
   optional?: boolean;
   /** Default value for the parameter */
   default?: Children;
+
   refkey?: Refkey;
-  symbol?: OutputSymbol;
 }
 
 /** Define a parameter to be used in class or interface method. */
@@ -30,6 +29,7 @@ export function Parameter(props: ParameterProps) {
   const memberSymbol = createParameterSymbol(props.name, {
     refkeys: props.refkey,
     type: TypeSlot.firstSymbol,
+    isNullable: props.optional,
   });
 
   return (

package/src/components/property/property.tsx

@@ -2,9 +2,11 @@ import {
   Block,
   Children,
   code,
+  createSymbolSlot,
   List,
   MemberDeclaration,
   MemberName,
+  Namekey,
   Refkey,
 } from "@alloy-js/core";
 import {
@@ -48,7 +50,7 @@ const getModifiers = makeModifiers<PropertyModifiers>([
 
 /** Properties for {@link Property} component */
 export interface PropertyProps extends AccessModifiers, PropertyModifiers {
-  name: string;
+  name: Namekey | string;
   refkey?: Refkey;
 
   /** Property type */
@@ -115,8 +117,12 @@ export interface PropertyProps extends AccessModifiers, PropertyModifiers {
  * ```
  */
 export function Property(props: PropertyProps) {
+  const TypeSlot = createSymbolSlot();
+
   const propertySymbol = createPropertySymbol(props.name, {
     refkeys: props.refkey,
+    isNullable: props.nullable,
+    type: TypeSlot.firstSymbol,
   });
 
   const modifiers = computeModifiersPrefix([
@@ -135,7 +141,7 @@ export function Property(props: PropertyProps) {
       <DocWhen doc={props.doc} />
       <AttributeList attributes={props.attributes} endline />
       {modifiers}
-      {props.type}
+      <TypeSlot>{props.type}</TypeSlot>
       {props.nullable && "?"} <MemberName />{" "}
       <Block newline inline>
         <List joiner=" ">

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

@@ -0,0 +1,96 @@
+import { ClassDeclaration } from "#components/class/declaration.jsx";
+import { Namespace } from "#components/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";
+import { SourceFile } from "./source-file.jsx";
+
+it("defines multiple source files with unique content", () => {
+  expect(
+    <Output>
+      <Namespace name="TestCode">
+        <SourceFile path="Test1.cs">
+          <ClassDeclaration public name="TestClass1" />
+        </SourceFile>
+        <SourceFile path="Test2.cs">
+          <ClassDeclaration public name="TestClass2" />
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  ).toRenderTo({
+    "Test1.cs": `
+      namespace TestCode;
+
+      public class TestClass1;
+    `,
+    "Test2.cs": `
+      namespace TestCode;
+
+      public class TestClass2;
+    `,
+  });
+});
+
+describe("format options", () => {
+  function FileWithFormatOptions(props: {
+    options: CSharpFormatOptions;
+    children: Children;
+  }) {
+    return (
+      <CSharpFormatOptions value={props.options}>
+        <SourceFile path="hi.cs">{props.children}</SourceFile>
+      </CSharpFormatOptions>
+    );
+  }
+
+  it("respect tabWidth", () => {
+    expect(
+      <FileWithFormatOptions options={{ tabWidth: 5 }}>
+        hello
+        <Indent>indented 5 spaces</Indent>
+      </FileWithFormatOptions>,
+    ).toRenderTo(`
+      hello
+           indented 5 spaces
+    `);
+  });
+
+  it("respect useTabs", () => {
+    expect(
+      <FileWithFormatOptions options={{ useTabs: true }}>
+        hello
+        <Indent>indented with tabs</Indent>
+      </FileWithFormatOptions>,
+    ).toRenderTo(`
+      hello
+      \tindented with tabs
+    `);
+  });
+
+  it("respect printWidth", () => {
+    expect(
+      <FileWithFormatOptions options={{ printWidth: 10 }}>
+        <Prose>this is too long</Prose>
+      </FileWithFormatOptions>,
+    ).toRenderTo(`
+      this is
+      too long
+    `);
+  });
+
+  it("CSharpFormatOptions takes precedence over FormatOptions", () => {
+    expect(
+      <FormatOptions value={{ tabWidth: 5 }}>
+        <CSharpFormatOptions value={{ tabWidth: 3 }}>
+          <SourceFile path="hi.cs">
+            hello
+            <Indent>indented 3 spaces</Indent>
+          </SourceFile>
+        </CSharpFormatOptions>
+      </FormatOptions>,
+    ).toRenderTo(`
+      hello
+         indented 3 spaces
+    `);
+  });
+});

package/src/components/{SourceFile.tsx → source-file/source-file.tsx}

@@ -1,3 +1,6 @@
+import { NamespaceScopes } from "#components/namespace-scopes.jsx";
+import { Reference } from "#components/Reference.jsx";
+import { UsingDirective } from "#components/UsingDirective.jsx";
 import {
   Block,
   Children,
@@ -6,18 +9,19 @@ import {
   Scope,
   useBinder,
 } from "@alloy-js/core";
-import { getGlobalNamespace } from "../contexts/global-namespace.js";
-import { useNamespaceContext } from "../contexts/namespace.js";
-import { CSharpSourceFileScope } from "../scopes/source-file.js";
-import { NamespaceSymbol } from "../symbols/namespace.js";
-import { NamespaceScopes } from "./namespace-scopes.jsx";
-import { Reference } from "./Reference.jsx";
-import { UsingDirective } from "./UsingDirective.jsx";
+import {
+  CSharpFormatOptions,
+  useCsharpFormatOptions,
+} from "../../contexts/format-options.js";
+import { getGlobalNamespace } from "../../contexts/global-namespace.js";
+import { useNamespaceContext } from "../../contexts/namespace.js";
+import { CSharpSourceFileScope } from "../../scopes/source-file.js";
+import { NamespaceSymbol } from "../../symbols/namespace.js";
 
 /**
  * Props for {@link SourceFile} component
  */
-export interface SourceFileProps {
+export interface SourceFileProps extends CSharpFormatOptions {
   /** Path of the source file */
   path: string;
 
@@ -48,13 +52,19 @@ export function SourceFile(props: SourceFileProps) {
   const content = computed(() => (
     <NamespaceScopes symbol={nsSymbol}>{props.children}</NamespaceScopes>
   ));
+
+  const opts = useCsharpFormatOptions({
+    printWidth: props.printWidth,
+    tabWidth: props.tabWidth,
+    useTabs: props.useTabs,
+  });
+
   return (
     <CoreSourceFile
       path={props.path}
       filetype="cs"
       reference={Reference}
-      tabWidth={4}
-      printWidth={120}
+      {...opts}
     >
       <Scope value={sourceFileScope}>
         {(sourceFileScope.usings.size > 0 ||

package/src/contexts/format-options.ts

@@ -0,0 +1,14 @@
+import {
+  CommonFormatOptions,
+  createFormatOptionsContextFor,
+} from "@alloy-js/core";
+
+export interface CSharpFormatOptions extends CommonFormatOptions {}
+
+export const {
+  Provider: CSharpFormatOptions,
+  useFormatOptions: useCsharpFormatOptions,
+} = createFormatOptionsContextFor<CSharpFormatOptions>("csharp", {
+  tabWidth: 4,
+  printWidth: 120,
+});

package/src/index.ts

@@ -1,4 +1,5 @@
 export * from "./components/index.js";
+export * from "./contexts/format-options.js";
 export * from "./modifiers.js";
 export * from "./name-policy.js";
 export * from "./scopes/index.js";