@alloy-js/csharp 0.20.0-dev.1 → 0.20.0-dev.10

package/src/components/property/property.tsx

@@ -2,11 +2,12 @@ import {
   Block,
   Children,
   code,
+  createSymbolSlot,
   List,
   MemberDeclaration,
-  refkey,
+  MemberName,
+  Namekey,
   Refkey,
-  Scope,
 } from "@alloy-js/core";
 import {
   AccessModifiers,
@@ -14,9 +15,7 @@ import {
   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 { createPropertySymbol } from "../../symbols/factories.js";
 import { AttributeList, AttributesProp } from "../attributes/attributes.jsx";
 import { DocWhen } from "../doc/comment.jsx";
 
@@ -51,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 */
@@ -118,27 +117,12 @@ export interface PropertyProps extends AccessModifiers, PropertyModifiers {
  * ```
  */
 export function Property(props: PropertyProps) {
-  const name = useCSharpNamePolicy().getName(props.name, "class-property");
-  const scope = useCSharpScope();
-  if (
-    scope.kind !== "member" ||
-    (scope.name !== "class-decl" &&
-      scope.name !== "record-decl" &&
-      scope.name !== "struct-decl")
-  ) {
-    throw new Error(
-      "can't define an interface method outside of an interface scope",
-    );
-  }
-
-  const propertySymbol = new CSharpOutputSymbol(name, {
-    scope,
-    refkeys: props.refkey ?? refkey(props.name),
-  });
+  const TypeSlot = createSymbolSlot();
 
-  // scope for property declaration
-  const propertyScope = new CSharpMemberScope("property-decl", {
-    owner: propertySymbol,
+  const propertySymbol = createPropertySymbol(props.name, {
+    refkeys: props.refkey,
+    isNullable: props.nullable,
+    type: TypeSlot.firstSymbol,
   });
 
   const modifiers = computeModifiersPrefix([
@@ -154,21 +138,19 @@ export function Property(props: PropertyProps) {
   // note that scope wraps the method decl so that the params get the correct scope
   return (
     <MemberDeclaration symbol={propertySymbol}>
-      <Scope value={propertyScope}>
-        <DocWhen doc={props.doc} />
-        <AttributeList attributes={props.attributes} endline />
-        {modifiers}
-        {props.type}
-        {props.nullable && "?"} {name}{" "}
-        <Block newline inline>
-          <List joiner=" ">
-            {props.get && "get;"}
-            {props.set && "set;"}
-            {props.init && "init;"}
-          </List>
-        </Block>
-        {props.initializer && code` = ${props.initializer};`}
-      </Scope>
+      <DocWhen doc={props.doc} />
+      <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};`}
     </MemberDeclaration>
   );
 }

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

@@ -1,9 +1,15 @@
+import { Children, code, refkey } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { Property } from "../property/property.jsx";
 import { RecordDeclaration } from "./declaration.jsx";
 
-it("declares class with no members", () => {
+// Remove Wrapper that added <SourceFile> because TestNamespace already does
+function Wrapper({ children }: { children: Children }) {
+  return <TestNamespace>{children}</TestNamespace>;
+}
+
+it("declares record with no members", () => {
   expect(
     <TestNamespace>
       <RecordDeclaration name="TestRecord" />
@@ -56,7 +62,7 @@ it("specify doc comment", () => {
   `);
 });
 
-it("specify class property inside", () => {
+it("specify record property inside", () => {
   expect(
     <TestNamespace>
       <RecordDeclaration name="TestRecord" doc="This is a test">
@@ -67,7 +73,45 @@ it("specify class property inside", () => {
     /// This is a test
     record TestRecord
     {
-      string Prop { get; set; }
+        string Prop { get; set; }
     }
   `);
 });
+
+describe("constructor", () => {
+  it("declares primary constructor with args", () => {
+    const paramNameRefkey = refkey();
+    const paramSizeRefkey = refkey();
+
+    const ctorParams = [
+      {
+        name: "name",
+        type: "string",
+        refkey: paramNameRefkey,
+      },
+      {
+        name: "size",
+        type: "int",
+        refkey: paramSizeRefkey,
+      },
+    ];
+
+    expect(
+      <Wrapper>
+        <RecordDeclaration public name="Test" primaryConstructor={ctorParams}>
+          <Property
+            name="PrettyName"
+            type="string"
+            get
+            initializer={code`$"{${paramNameRefkey}} {${paramSizeRefkey}}"`}
+          />
+        </RecordDeclaration>
+      </Wrapper>,
+    ).toRenderTo(`
+      public record Test(string name, int size)
+      {
+          string PrettyName { get; } = $"{name} {size}";
+      }
+  `);
+  });
+});

package/src/components/record/declaration.tsx

@@ -6,10 +6,14 @@ import {
   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 { createClassScope } from "../../scopes/factories.js";
+import {
+  createNamedTypeSymbol,
+  createTypeParameterSymbol,
+} from "../../symbols/factories.js";
 import { DocWhen } from "../doc/comment.jsx";
 import { Name } from "../Name.jsx";
+import { ParameterProps, Parameters } from "../parameters/parameters.jsx";
 
 export interface RecordModifiers {
   readonly partial?: boolean;
@@ -28,6 +32,24 @@ export interface RecordDeclarationProps
   doc?: core.Children;
   refkey?: core.Refkey;
   typeParameters?: Record<string, core.Refkey>;
+
+  /**
+   * Set the primary constructor parameters
+   * @example
+   * ```tsx
+   *  <ClassDeclaration name="MyClass" primaryConstructor={[
+   *    {name: "value", type: "int"}
+   *  ]}>
+   * ```
+   * This will produce:
+   * ```csharp
+   * public class MyClass(int value)
+   * {
+   *
+   * }
+   * ```
+   */
+  primaryConstructor?: ParameterProps[];
 }
 
 /**
@@ -53,17 +75,13 @@ export interface RecordDeclarationProps
 export function RecordDeclaration(props: RecordDeclarationProps) {
   const name = useCSharpNamePolicy().getName(props.name!, "record");
 
-  const thisRecordSymbol = new CSharpOutputSymbol(name, {
+  // 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", {
     refkeys: props.refkey,
   });
 
-  // this creates a new scope for the record definition.
-  // members will automatically "inherit" this scope so
-  // that refkeys to them will produce the fully-qualified
-  // name e.g. Foo.Bar.
-  const thisRecordScope = new CSharpMemberScope("record-decl", {
-    owner: thisRecordSymbol,
-  });
+  const thisRecordScope = createClassScope(thisRecordSymbol);
 
   let typeParams: core.Children;
   if (props.typeParameters) {
@@ -74,7 +92,7 @@ export function RecordDeclaration(props: RecordDeclarationProps) {
       );
       // create a symbol for each type param so its
       // refkey resolves to the type param's name
-      new CSharpOutputSymbol(entry[0], {
+      createTypeParameterSymbol(entry[0], {
         scope: thisRecordScope,
         refkeys: entry[1],
       });
@@ -99,6 +117,11 @@ export function RecordDeclaration(props: RecordDeclarationProps) {
       <DocWhen doc={props.doc} />
       {modifiers}record <Name />
       {typeParams}
+      {props.primaryConstructor && (
+        <core.Scope value={thisRecordScope}>
+          <Parameters parameters={props.primaryConstructor} />
+        </core.Scope>
+      )}
       {props.children ?
         <core.Block newline>
           <core.Scope value={thisRecordScope}>{props.children}</core.Scope>

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/source-file/source-file.tsx

@@ -0,0 +1,98 @@
+import { NamespaceScopes } from "#components/namespace-scopes.jsx";
+import { Reference } from "#components/Reference.jsx";
+import { UsingDirective } from "#components/UsingDirective.jsx";
+import {
+  Block,
+  Children,
+  computed,
+  SourceFile as CoreSourceFile,
+  Scope,
+  useBinder,
+} from "@alloy-js/core";
+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 extends CSharpFormatOptions {
+  /** Path of the source file */
+  path: string;
+
+  /** Source file content */
+  children?: Children;
+
+  /**
+   * A list of using directives to explicitly include. Note that providing
+   * explicit usings is not necessary when referencing symbols via refkeys.
+   */
+  using?: string[];
+}
+
+/** A C# source file exists within the context of a namespace contains using statements and declarations */
+export function SourceFile(props: SourceFileProps) {
+  const sourceFileScope = new CSharpSourceFileScope(props.path);
+
+  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)[]
+    ).concat(props.using ?? []);
+  });
+
+  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}
+      {...opts}
+    >
+      <Scope value={sourceFileScope}>
+        {(sourceFileScope.usings.size > 0 ||
+          (props.using && props.using.length > 0)) && (
+          <>
+            <UsingDirective namespaces={usings.value} />
+            <hbr />
+            <hbr />
+          </>
+        )}
+        {nsSymbol === globalNs ?
+          content
+        : <>
+            namespace {nsRef}
+            {sourceFileScope.hasBlockNamespace ?
+              <>
+                {" "}
+                <Block>{content}</Block>
+              </>
+            : <>
+                ;<hbr />
+                <hbr />
+                {content}
+              </>
+            }
+          </>
+        }
+      </Scope>
+    </CoreSourceFile>
+  );
+}

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

@@ -6,7 +6,6 @@ import { Constructor } from "../constructor/constructor.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 { TypeParameterProps } from "../type-parameters/type-parameter.jsx";
 import { StructDeclaration } from "./declaration.jsx";
 
@@ -78,23 +77,18 @@ describe("with type parameters", () => {
 
     expect(
       <TestNamespace>
-        <SourceFile path="Test.cs">
-          <StructDeclaration public name="Test" typeParameters={typeParameters}>
-            <List>
-              <Property name="PropA" type={typeParameters[0].refkey} get set />
-              <Property name="PropB" type={typeParameters[1].refkey} get set />
-            </List>
-          </StructDeclaration>
-        </SourceFile>
+        <StructDeclaration public name="Test" typeParameters={typeParameters}>
+          <List>
+            <Property name="PropA" type={typeParameters[0].refkey} get set />
+            <Property name="PropB" type={typeParameters[1].refkey} get set />
+          </List>
+        </StructDeclaration>
       </TestNamespace>,
     ).toRenderTo(`
-      namespace TestCode
+      public struct Test<T, U>
       {
-          public struct Test<T, U>
-          {
-              T PropA { get; set; }
-              U PropB { get; set; }
-          }
+          T PropA { get; set; }
+          U PropB { get; set; }
       }
     `);
   });
@@ -119,10 +113,10 @@ describe("with type parameters", () => {
       </TestNamespace>,
     ).toRenderTo(`
       public struct Test<T, U>
-        where T : IFoo
-        where U : IBar
+          where T : IFoo
+          where U : IBar
       {
-        // Body
+          // Body
       }
     `);
   });
@@ -149,7 +143,7 @@ it("define methods", () => {
   ).toRenderTo(`
     struct Test
     {
-      void MethodOne() {}
+        void MethodOne() {}
     }
   `);
 });
@@ -164,7 +158,7 @@ it("define constructor", () => {
   ).toRenderTo(`
     struct Test
     {
-      public Test() {}
+        public Test() {}
     }
   `);
 });
@@ -182,8 +176,8 @@ it("defines fields", () => {
   ).toRenderTo(`
     public struct TestClass
     {
-      public string MemberOne;
-      public int MemberTwo;
+        public string MemberOne;
+        public int MemberTwo;
     }
   `);
 });

package/src/components/struct/declaration.tsx

@@ -7,8 +7,8 @@ import {
   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 { createNamedTypeScope } from "../../scopes/factories.js";
+import { createNamedTypeSymbol } from "../../symbols/factories.js";
 import { AttributeList, AttributesProp } from "../attributes/attributes.jsx";
 import { DocWhen } from "../doc/comment.jsx";
 import { Name } from "../Name.jsx";
@@ -100,13 +100,11 @@ export interface StructDeclarationProps
 export function StructDeclaration(props: StructDeclarationProps) {
   const name = useCSharpNamePolicy().getName(props.name!, "struct");
 
-  const thisStructSymbol = new CSharpOutputSymbol(name, {
+  const thisStructSymbol = createNamedTypeSymbol(name, "struct", {
     refkeys: props.refkey,
   });
 
-  const thisStructScope = new CSharpMemberScope("struct-decl", {
-    owner: thisStructSymbol,
-  });
+  const thisStructScope = createNamedTypeScope(thisStructSymbol);
 
   const modifiers = computeModifiersPrefix([
     getAccessModifier(props),

package/src/components/type-parameters/type-parameter.tsx

@@ -1,7 +1,10 @@
-import { Children, MemberDeclaration, refkey, Refkey } from "@alloy-js/core";
-import { useCSharpNamePolicy } from "../../name-policy.js";
-import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
-import { useCSharpScope } from "../../symbols/scopes.js";
+import {
+  Children,
+  MemberDeclaration,
+  MemberName,
+  Refkey,
+} from "@alloy-js/core";
+import { createTypeParameterSymbol } from "../../symbols/factories.js";
 
 /**
  * Information for a TypeScript generic type parameter.
@@ -24,12 +27,12 @@ export interface TypeParameterProps {
 }
 
 export function TypeParameter(props: TypeParameterProps) {
-  const name = useCSharpNamePolicy().getName(props.name, "type-parameter");
-  const scope = useCSharpScope();
-  const symbol = new CSharpOutputSymbol(name, {
-    scope,
-    refkeys: props.refkey ?? refkey(props.name),
+  const symbol = createTypeParameterSymbol(props.name, {
+    refkeys: props.refkey,
   });
-
-  return <MemberDeclaration symbol={symbol}>{name}</MemberDeclaration>;
+  return (
+    <MemberDeclaration symbol={symbol}>
+      <MemberName />
+    </MemberDeclaration>
+  );
 }

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

@@ -15,16 +15,16 @@ it("render very long", () => {
     <TestNamespace>
       <TypeParameters
         parameters={[
-          "SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesA",
-          "SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesB",
+          "SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesLongLongLongLongLongA",
+          "SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesLongLongLongLongLongB",
         ]}
       />
     </TestNamespace>,
   ).toRenderTo(
     `
     <
-      SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesA,
-      SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesB>
+        SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesLongLongLongLongLongA,
+        SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesLongLongLongLongLongB>
     `,
   );
 });

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

@@ -1,7 +1,6 @@
 import { List, refkey } from "@alloy-js/core";
 import { expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
-import { SourceFile } from "../SourceFile.jsx";
 import { VarDeclaration } from "./declaration.jsx";
 
 it("declares var without type", () => {
@@ -40,20 +39,15 @@ it("links refkey", () => {
   const key = refkey();
   expect(
     <TestNamespace>
-      <SourceFile path="test.cs">
-        <List>
-          <VarDeclaration name="testVar" refkey={key}>
-            42
-          </VarDeclaration>
-          <VarDeclaration name="testVar2">{key}</VarDeclaration>
-        </List>
-      </SourceFile>
+      <List>
+        <VarDeclaration name="testVar" refkey={key}>
+          42
+        </VarDeclaration>
+        <VarDeclaration name="testVar2">{key}</VarDeclaration>
+      </List>
     </TestNamespace>,
   ).toRenderTo(`
-      namespace TestCode
-      {
-          var testVar = 42;
-          var testVar2 = testVar;
-      }
+      var testVar = 42;
+      var testVar2 = testVar;
   `);
 });