@alloy-js/csharp 0.20.0-dev.2 → 0.20.0-dev.4

package/src/components/Declaration.tsx

@@ -1,18 +1,15 @@
 import * as core from "@alloy-js/core";
-import { CSharpOutputSymbol } from "../symbols/csharp-output-symbol.js";
 
 // properties for creating a declaration
 export interface DeclarationProps {
   name: string;
-  refkey?: core.Refkey;
+  refkey?: core.Refkey | core.Refkey[];
   children?: core.Children;
 }
 
 // declares a symbol in the program (class, enum, interface etc)
 export function Declaration(props: DeclarationProps) {
-  const sym = new CSharpOutputSymbol(props.name, {
-    refkeys: props.refkey,
-  });
+  throw new Error("Not supported");
 
-  return <core.Declaration symbol={sym}>{props.children}</core.Declaration>;
+  //return <core.Declaration symbol={sym}>{props.children}</core.Declaration>;
 }

package/src/components/Reference.tsx

@@ -8,6 +8,8 @@ export interface ReferenceProps {
 // used to resolve refkey references within source files
 export function Reference({ refkey }: ReferenceProps) {
   const reference = ref(refkey);
+  const symbolRef = core.computed(() => reference()[1]);
 
-  return <>{reference}</>;
+  core.emitSymbol(symbolRef);
+  return <>{reference()[0]}</>;
 }

package/src/components/SourceFile.tsx

@@ -1,78 +1,91 @@
-import * as core from "@alloy-js/core";
-import { useNamespace } from "./Namespace.jsx";
+import {
+  Children,
+  computed,
+  SourceFile as CoreSourceFile,
+  Scope,
+  Show,
+  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 { NamespaceScope, NamespaceScopes } from "./namespace-scopes.jsx";
 import { Reference } from "./Reference.jsx";
 import { UsingDirective } from "./UsingDirective.jsx";
 
-// contains the info for the current source file
-export interface SourceFileContext {
-  // adds a namespace to the array of using statements
-  addUsing(namespace: string): void;
-}
-
-const SourceFileContext = core.createContext<SourceFileContext>();
-
-// returns the current source file
-export function useSourceFile(): SourceFileContext | undefined {
-  return core.useContext(SourceFileContext) as SourceFileContext;
-}
-
 export interface SourceFileProps {
   /** Path of the source file */
   path: string;
 
-  /** A list of namespaces to use */
-  using?: Array<string>;
+  children?: Children;
 
-  children?: core.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 namespaceCtx = useNamespace();
-
-  if (!namespaceCtx) {
-    throw new Error("SourceFile must be declared inside a namespace");
-  }
-
-  const using: Array<string> = core.reactive(new Array<string>());
-  if (props.using) {
-    using.push(...props.using);
-  }
-
-  // adds the specified namespace to the array of using statements.
-  // called via SourceFileContext.addUsing when resolving refkeys.
-  function addUsing(namespace: string): void {
-    if (!using.includes(namespace)) {
-      using.push(namespace);
-    }
-  }
-
-  const sourceFileCtx: SourceFileContext = {
-    addUsing,
-  };
+  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 ?? []);
+  });
   return (
-    <core.SourceFile
+    <CoreSourceFile
       path={props.path}
       filetype="cs"
       reference={Reference}
       tabWidth={4}
       printWidth={120}
     >
-      <SourceFileContext.Provider value={sourceFileCtx}>
-        <core.Scope name={props.path} kind="source-file">
-          {using.length > 0 && (
-            <>
-              <UsingDirective namespaces={using} />
-              <hbr />
-              <hbr />
-            </>
-          )}
-          namespace {namespaceCtx.name}
-          <core.Block newline>{props.children}</core.Block>
-        </core.Scope>
-      </SourceFileContext.Provider>
-    </core.SourceFile>
+      <Scope value={sourceFileScope}>
+        {(sourceFileScope.usings.size > 0 ||
+          (props.using && props.using.length > 0)) && (
+          <>
+            <UsingDirective namespaces={usings.value} />
+            <hbr />
+            <hbr />
+          </>
+        )}
+        <Show when={!!nsContext && nsSymbol !== globalNs}>
+          <Show when={sourceFileScope.hasBlockNamespace}>
+            namespace {nsRef}
+            {" {"}
+            <hbr />
+            {"    "}
+          </Show>
+
+          <Show when={!sourceFileScope.hasBlockNamespace}>
+            namespace {nsRef};<hbr />
+            <hbr />
+          </Show>
+          <align width={sourceFileScope.hasBlockNamespace ? 4 : 0}>
+            <NamespaceScopes symbol={nsContext!.symbol}>
+              {props.children}
+            </NamespaceScopes>
+          </align>
+          <Show when={sourceFileScope.hasBlockNamespace}>
+            <hbr />
+            {"}"}
+          </Show>
+        </Show>
+        <Show when={!nsContext || nsSymbol === globalNs}>
+          <NamespaceScope symbol={getGlobalNamespace(useBinder())}>
+            {props.children}
+          </NamespaceScope>
+        </Show>
+      </Scope>
+    </CoreSourceFile>
   );
 }

package/src/components/UsingDirective.tsx

@@ -1,13 +1,23 @@
 import * as core from "@alloy-js/core";
+import { NamespaceSymbol } from "../symbols/namespace.js";
 
 export interface UsingDirectiveProps {
-  namespaces: Array<string>;
+  /**
+   * Namespace symbols or namespace names to use to generate using statements.
+   */
+  namespaces?: (NamespaceSymbol | string)[];
 }
 
 // one ore more C# using directives
 export function UsingDirective(props: UsingDirectiveProps) {
   const sortedNamespaces = core.computed(() => {
-    return props.namespaces.sort();
+    return props
+      .namespaces!.map((ns) =>
+        typeof ns === "string" ? ns : (
+          ns.getFullyQualifiedName({ omitGlobal: true })
+        ),
+      )
+      .sort((n1, n2) => n1.localeCompare(n2));
   });
 
   return (

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

@@ -1,3 +1,6 @@
+import { Constructor } from "#components/constructor/constructor.jsx";
+import { EnumDeclaration } from "#components/enum/declaration.jsx";
+import { EnumMember } from "#components/enum/member.jsx";
 import {
   Children,
   code,
@@ -15,19 +18,13 @@ import { createCSharpNamePolicy } from "../../name-policy.js";
 import { Attribute } from "../attributes/attributes.jsx";
 import { Field } from "../field/field.jsx";
 import { Method } from "../method/method.jsx";
-import { Namespace } from "../Namespace.jsx";
 import { Property } from "../property/property.jsx";
 import { SourceFile } from "../SourceFile.jsx";
-import { Constructor, EnumDeclaration, EnumMember } from "../stc/index.js";
 import { TypeParameterProps } from "../type-parameters/type-parameter.jsx";
 import { ClassDeclaration } from "./declaration.jsx";
 
 function Wrapper({ children }: { children: Children }) {
-  return (
-    <TestNamespace>
-      <SourceFile path="Test.cs">{children}</SourceFile>
-    </TestNamespace>
-  );
+  return <TestNamespace>{children}</TestNamespace>;
 }
 
 it("declares class with no members", () => {
@@ -70,6 +67,24 @@ describe("modifiers", () => {
         public abstract partial class TestClass;
     `);
   });
+
+  it("places visibility, attributes, and modifiers in the correct order", () => {
+    expect(
+      <TestNamespace>
+        <ClassDeclaration
+          partial
+          public
+          abstract
+          sealed
+          name="TestClass"
+          attributes={[<Attribute name="Test" />]}
+        />
+      </TestNamespace>,
+    ).toRenderTo(`
+        [Test]
+        public abstract sealed partial class TestClass;
+    `);
+  });
 });
 
 describe("base", () => {
@@ -109,45 +124,43 @@ describe("base", () => {
 });
 
 it("declares class with some members", () => {
-  const res = toSourceText(
-    <ClassDeclaration public name="TestClass">
-      <List>
-        <Field public name="MemberOne" type="string" />
-        <Field public name="MemberTwo" type="int" />
-      </List>
-    </ClassDeclaration>,
+  const tree = (
+    <TestNamespace>
+      <ClassDeclaration public name="TestClass">
+        <List>
+          <Field public name="MemberOne" type="string" />
+          <Field public name="MemberTwo" type="int" />
+        </List>
+      </ClassDeclaration>
+    </TestNamespace>
   );
 
-  expect(res).toBe(coretest.d`
-    namespace TestCode
+  expect(tree).toRenderTo(coretest.d`
+    public class TestClass
     {
-        public class TestClass
-        {
-            public string MemberOne;
-            public int MemberTwo;
-        }
+        public string MemberOne;
+        public int MemberTwo;
     }
   `);
 });
 
 it("declares class with some methods", () => {
-  const res = toSourceText(
-    <ClassDeclaration public name="TestClass">
-      <List>
-        <Method public name="MethodOne" />
-        <Method private virtual name="MethodTwo" />
-      </List>
-    </ClassDeclaration>,
+  const tree = (
+    <TestNamespace>
+      <ClassDeclaration public name="TestClass">
+        <List>
+          <Method public name="MethodOne" />
+          <Method private virtual name="MethodTwo" />
+        </List>
+      </ClassDeclaration>
+    </TestNamespace>
   );
 
-  expect(res).toBe(coretest.d`
-    namespace TestCode
+  expect(tree).toRenderTo(coretest.d`
+    public class TestClass
     {
-        public class TestClass
-        {
-            public void MethodOne() {}
-            private virtual void MethodTwo() {}
-        }
+        public void MethodOne() {}
+        private virtual void MethodTwo() {}
     }
   `);
 });
@@ -170,57 +183,52 @@ it("uses refkeys for members, params, and return type", () => {
 
   const res = render(
     <Output namePolicy={createCSharpNamePolicy()}>
-      <Namespace name="TestCode">
-        <SourceFile path="Test.cs">
-          <EnumDeclaration public name="TestEnum" refkey={enumTypeRefkey}>
-            <List comma hardline>
-              <EnumMember name="One" />
-              <EnumMember name="Two" />
-            </List>
-          </EnumDeclaration>
-          <hbr />
-          <ClassDeclaration public name="TestInput" refkey={inputTypeRefkey} />
+      <SourceFile path="Test.cs">
+        <EnumDeclaration public name="TestEnum" refkey={enumTypeRefkey}>
+          <List comma hardline>
+            <EnumMember name="One" />
+            <EnumMember name="Two" />
+          </List>
+        </EnumDeclaration>
+        <hbr />
+        <ClassDeclaration public name="TestInput" refkey={inputTypeRefkey} />
+        <hbr />
+        <ClassDeclaration
+          public
+          name="TestResult"
+          refkey={testResultTypeRefkey}
+        />
+        <hbr />
+        <ClassDeclaration public name="TestClass">
+          <Field private name="MemberOne" type={enumTypeRefkey} />
           <hbr />
-          <ClassDeclaration
+          <Method
             public
-            name="TestResult"
-            refkey={testResultTypeRefkey}
-          />
-          <hbr />
-          <ClassDeclaration public name="TestClass">
-            <Field private name="MemberOne" type={enumTypeRefkey} />
-            <hbr />
-            <Method
-              public
-              name="MethodOne"
-              parameters={params}
-              returns={testResultTypeRefkey}
-            >
-              return new {testResultTypeRefkey}();
-            </Method>
-          </ClassDeclaration>
-        </SourceFile>
-      </Namespace>
+            name="MethodOne"
+            parameters={params}
+            returns={testResultTypeRefkey}
+          >
+            return new {testResultTypeRefkey}();
+          </Method>
+        </ClassDeclaration>
+      </SourceFile>
     </Output>,
   );
 
   expect(findFile(res, "Test.cs").contents).toBe(coretest.d`
-    namespace TestCode
+    public enum TestEnum
     {
-        public enum TestEnum
-        {
-            One,
-            Two
-        }
-        public class TestInput;
-        public class TestResult;
-        public class TestClass
+        One,
+        Two
+    }
+    public class TestInput;
+    public class TestResult;
+    public class TestClass
+    {
+        private TestEnum _memberOne;
+        public TestResult MethodOne(int intParam, TestInput bodyParam)
         {
-            private TestEnum _memberOne;
-            public TestResult MethodOne(int intParam, TestInput bodyParam)
-            {
-                return new TestResult();
-            }
+            return new TestResult();
         }
     }
   `);
@@ -241,27 +249,22 @@ describe("with type parameters", () => {
 
     expect(
       <TestNamespace>
-        <SourceFile path="Test.cs">
-          <ClassDeclaration
-            public
-            name="TestClass"
-            typeParameters={typeParameters}
-          >
-            <List>
-              <Property name="PropA" type={typeParameters[0].refkey} get set />
-              <Property name="PropB" type={typeParameters[1].refkey} get set />
-            </List>
-          </ClassDeclaration>
-        </SourceFile>
+        <ClassDeclaration
+          public
+          name="TestClass"
+          typeParameters={typeParameters}
+        >
+          <List>
+            <Property name="PropA" type={typeParameters[0].refkey} get set />
+            <Property name="PropB" type={typeParameters[1].refkey} get set />
+          </List>
+        </ClassDeclaration>
       </TestNamespace>,
     ).toRenderTo(`
-      namespace TestCode
+      public class TestClass<T, U>
       {
-          public class TestClass<T, U>
-          {
-              T PropA { get; set; }
-              U PropB { get; set; }
-          }
+          T PropA { get; set; }
+          U PropB { get; set; }
       }
     `);
   });
@@ -290,10 +293,10 @@ describe("with type parameters", () => {
       </TestNamespace>,
     ).toRenderTo(`
       public class TestClass<T, U>
-        where T : IFoo
-        where U : IBar
+          where T : IFoo
+          where U : IBar
       {
-        // Body
+          // Body
       }
     `);
   });
@@ -308,25 +311,24 @@ it("declares class with invalid members", () => {
   );
 
   expect(() => toSourceText(decl)).toThrow(
-    "can't define an enum member outside of an enum-decl scope",
+    "EnumMember must be used within an EnumDeclaration.",
   );
 });
 
 describe("constructor", () => {
   it("declares with constructor", () => {
-    const res = toSourceText(
-      <ClassDeclaration public name="TestClass">
-        <Constructor public />
-      </ClassDeclaration>,
+    const tree = (
+      <TestNamespace>
+        <ClassDeclaration public name="TestClass">
+          <Constructor public />
+        </ClassDeclaration>
+      </TestNamespace>
     );
 
-    expect(res).toBe(coretest.d`
-    namespace TestCode
+    expect(tree).toRenderTo(coretest.d`
+    public class TestClass
     {
-        public class TestClass
-        {
-            public TestClass() {}
-        }
+        public TestClass() {}
     }
   `);
   });
@@ -350,33 +352,32 @@ describe("constructor", () => {
       },
     ];
 
-    const res = toSourceText(
-      <ClassDeclaration public name="TestClass">
-        <Field private name="name" type="string" refkey={thisNameRefkey} />
-        <hbr />
-        <Field private name="size" type="int" refkey={thisSizeRefkey} />
-        <hbr />
-        <Constructor public parameters={ctorParams}>
-          {thisNameRefkey} = {paramNameRefkey};<hbr />
-          {thisSizeRefkey} = {paramSizeRefkey};
-        </Constructor>
-      </ClassDeclaration>,
+    const tree = (
+      <TestNamespace>
+        <ClassDeclaration public name="TestClass">
+          <Field private name="name" type="string" refkey={thisNameRefkey} />
+          <hbr />
+          <Field private name="size" type="int" refkey={thisSizeRefkey} />
+          <hbr />
+          <Constructor public parameters={ctorParams}>
+            {thisNameRefkey} = {paramNameRefkey};<hbr />
+            {thisSizeRefkey} = {paramSizeRefkey};
+          </Constructor>
+        </ClassDeclaration>
+      </TestNamespace>
     );
 
     // TODO: assignments to members should have this. prefix
     // e.g. this.name = name;
-    expect(res).toBe(coretest.d`
-    namespace TestCode
+    expect(tree).toRenderTo(coretest.d`
+    public class TestClass
     {
-        public class TestClass
+        private string _name;
+        private int _size;
+        public TestClass(string name, int size)
         {
-            private string _name;
-            private int _size;
-            public TestClass(string name, int size)
-            {
-                _name = name;
-                _size = size;
-            }
+            _name = name;
+            _size = size;
         }
     }
   `);
@@ -415,12 +416,9 @@ describe("constructor", () => {
         </ClassDeclaration>
       </Wrapper>,
     ).toRenderTo(`
-      namespace TestCode
+      public class TestClass(string name, int size)
       {
-          public class TestClass(string name, int size)
-          {
-              string PrettyName { get; } = $"{name} {size}";
-          }
+          string PrettyName { get; } = $"{name} {size}";
       }
   `);
   });
@@ -441,12 +439,9 @@ describe("constructor", () => {
         </NamePolicyContext.Provider>
       </Wrapper>,
     ).toRenderTo(`
-      namespace TestCode
+      public class TestClass(string name)
       {
-          public class TestClass(string name)
-          {
-              string name_2;
-          }
+          string name_2;
       }
   `);
   });
@@ -474,8 +469,8 @@ it("supports class member doc comments", () => {
     /// This is a test
     class Test
     {
-      /// This is a member
-      public int Member;
+        /// This is a member
+        public int Member;
     }
   `);
 });