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

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/factories.ts

@@ -1,6 +1,7 @@
 import {
   Namekey,
   NamePolicyGetter,
+  onCleanup,
   OutputSymbolOptions,
   useBinder,
 } from "@alloy-js/core";
@@ -99,13 +100,22 @@ export function createFieldSymbol(
   );
 }
 
+function withCleanup<T extends CSharpSymbol>(sym: T): T {
+  onCleanup(() => {
+    sym.delete();
+  });
+  return sym;
+}
+
 export function createNamedTypeSymbol(
   name: string | Namekey,
   kind: NamedTypeTypeKind,
   options?: OutputSymbolOptions,
 ) {
   const scope = useNamedTypeScope();
-  return new NamedTypeSymbol(name, scope.ownerSymbol.members, kind, options);
+  return withCleanup(
+    new NamedTypeSymbol(name, scope.ownerSymbol.members, kind, options),
+  );
 }
 
 export function createNamespaceSymbol(name: string) {
@@ -114,7 +124,7 @@ export function createNamespaceSymbol(name: string) {
   if (nsSymbol.members.symbolNames.has(name)) {
     return nsSymbol.members.symbolNames.get(name)! as NamespaceSymbol;
   }
-  return new NamespaceSymbol(name, nsSymbol);
+  return withCleanup(new NamespaceSymbol(name, nsSymbol));
 }
 
 export interface CreateMethodSymbolOptions extends CSharpSymbolOptions {
@@ -137,11 +147,13 @@ export function createMethodSymbol(
     );
   }
 
-  return new MethodSymbol(
-    originalName,
-    scope.members,
-    options.methodKind ?? "ordinary",
-    withNamePolicy(options, "class-method"),
+  return withCleanup(
+    new MethodSymbol(
+      originalName,
+      scope.members,
+      options.methodKind ?? "ordinary",
+      withNamePolicy(options, "class-method"),
+    ),
   );
 }
 
@@ -150,10 +162,12 @@ export function createPropertySymbol(
   options: CSharpSymbolOptions,
 ) {
   const scope = useNamedTypeScope();
-  return new CSharpSymbol(
-    name,
-    scope.members,
-    withNamePolicy(options, "class-property"),
+  return withCleanup(
+    new CSharpSymbol(
+      name,
+      scope.members,
+      withNamePolicy(options, "class-property"),
+    ),
   );
 }
 
@@ -181,10 +195,12 @@ export function createVariableSymbol(
       `Can't create variable symbol outside of a lexical scope, got a ${scope.constructor.name}.`,
     );
   }
-  return new CSharpSymbol(
-    originalName,
-    scope.localVariables,
-    withNamePolicy(options, "variable"),
+  return withCleanup(
+    new CSharpSymbol(
+      originalName,
+      scope.localVariables,
+      withNamePolicy(options, "variable"),
+    ),
   );
 }
 

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];
   });
 }