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

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/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";

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/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/scopes/csharp.ts

@@ -1,4 +1,5 @@
 import { OutputScope, OutputScopeOptions } from "@alloy-js/core";
+import type { CSharpSymbol } from "../symbols/csharp.js";
 import { NamespaceSymbol } from "../symbols/namespace.js";
 
 export class CSharpScope extends OutputScope {
@@ -15,4 +16,8 @@ export class CSharpScope extends OutputScope {
   get enclosingNamespace() {
     return this.#namespaceSymbol;
   }
+
+  get ownerSymbol(): CSharpSymbol | undefined {
+    return super.ownerSymbol as CSharpSymbol | undefined;
+  }
 }

package/src/symbols/csharp.ts

@@ -33,6 +33,10 @@ export interface CSharpSymbolOptions extends OutputSymbolOptions {
   isSealed?: boolean;
   isExtern?: boolean;
   isReadOnly?: boolean;
+  /**
+   * Whether the value held by this symbol could be null.
+   */
+  isNullable?: boolean;
 }
 
 export type CSharpSymbolKinds =
@@ -72,6 +76,7 @@ export class CSharpSymbol extends OutputSymbol {
     this.#isSealed = options.isSealed ?? false;
     this.#isExtern = options.isExtern ?? false;
     this.#isReadOnly = options.isReadOnly ?? false;
+    this.#isNullable = options.isNullable; // undefined means unset, here.
   }
 
   get enclosingNamespace(): NamespaceSymbol | undefined {
@@ -280,6 +285,33 @@ export class CSharpSymbol extends OutputSymbol {
     trigger(this, TriggerOpTypes.SET, "isReadOnly", value, old);
   }
   #isReadOnly: boolean = false;
+
+  #isNullable: boolean | undefined = undefined;
+
+  /**
+   * Whether this symbol might contain null. True if this symbol has a
+   * `typeSymbol` and that symbol is nullable, or else when this symbol has the
+   * `nullable` option set.
+   */
+  get isNullable() {
+    if (this.hasTypeSymbol && this.#isNullable === undefined) {
+      return (this.type! as CSharpSymbol).isNullable;
+    }
+
+    track(this, TrackOpTypes.GET, "isNullable");
+    return !!this.#isNullable;
+  }
+
+  set isNullable(value: boolean) {
+    const old = this.#isNullable;
+    if (old === value) {
+      return;
+    }
+
+    this.#isNullable = value;
+
+    trigger(this, TriggerOpTypes.SET, "isNullable", value, old);
+  }
 }
 
 export function accessibilityFromProps(props: AccessModifiers) {

package/src/symbols/{reference.ts → reference.tsx}

@@ -1,4 +1,5 @@
-import { memo, OutputSymbol, Refkey, resolve } from "@alloy-js/core";
+import { AccessExpression } from "#components/access-expression/access-expression.jsx";
+import { Children, memo, OutputSymbol, Refkey, resolve } from "@alloy-js/core";
 import { CSharpScope } from "../scopes/csharp.js";
 import { CSharpNamespaceScope } from "../scopes/namespace.js";
 import { useSourceFileScope } from "../scopes/source-file.js";
@@ -9,10 +10,11 @@ import { NamespaceSymbol } from "./namespace.js";
 // e.g. if refkey is for bar in enum type foo, and
 // foo is in the same namespace as the refkey, then
 // the result would be foo.bar.
-export function ref(refkey: Refkey): () => [string, OutputSymbol | undefined] {
+export function ref(
+  refkey: Refkey,
+): () => [Children, OutputSymbol | undefined] {
   const refSfScope = useSourceFileScope()!;
   const resolveResult = resolve<CSharpScope, CSharpSymbol>(refkey as Refkey);
-
   return memo(() => {
     if (resolveResult.value === undefined) {
       return ["<Unresolved Symbol>", undefined];
@@ -22,7 +24,6 @@ export function ref(refkey: Refkey): () => [string, OutputSymbol | undefined] {
     const { commonScope, pathDown, memberPath } = result;
     let { lexicalDeclaration } = result;
 
-    const parts = [];
     if (!commonScope) {
       // this shouldn't be possible in csharp.
       return ["<Unresolved Symbol>", undefined];
@@ -47,16 +48,17 @@ export function ref(refkey: Refkey): () => [string, OutputSymbol | undefined] {
       refSfScope.addUsing(nsToUse!);
     }
 
+    const parts = [];
+
     for (const nsScope of pathDown) {
-      parts.push(nsScope.ownerSymbol!.name);
+      parts.push(<AccessExpression.Part symbol={nsScope.ownerSymbol!} />);
     }
 
-    parts.push(lexicalDeclaration.name);
-
+    parts.push(<AccessExpression.Part symbol={lexicalDeclaration} />);
     for (const member of memberPath) {
-      parts.push(member.name);
+      parts.push(<AccessExpression.Part symbol={member} />);
     }
 
-    return [parts.join("."), result.symbol];
+    return [<AccessExpression children={parts} />, result.symbol];
   });
 }